strongdm.models

    1# Copyright 2020 StrongDM Inc
    2#
    3# Licensed under the Apache License, Version 2.0 (the "License");
    4# you may not use this file except in compliance with the License.
    5# You may obtain a copy of the License at
    6#
    7#     http://www.apache.org/licenses/LICENSE-2.0
    8#
    9# Unless required by applicable law or agreed to in writing, software
   10# distributed under the License is distributed on an "AS IS" BASIS,
   11# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   12# See the License for the specific language governing permissions and
   13# limitations under the License.
   14#
   15
   16# This file was generated by protogen. DO NOT EDIT.
   17
   18import collections
   19
   20
   21class AKS:
   22    '''
   23
   24    '''
   25    __slots__ = [
   26        'bind_interface',
   27        'certificate_authority',
   28        'client_certificate',
   29        'client_key',
   30        'egress_filter',
   31        'healthcheck_namespace',
   32        'healthy',
   33        'hostname',
   34        'id',
   35        'name',
   36        'port',
   37        'remote_identity_group_id',
   38        'remote_identity_healthcheck_username',
   39        'secret_store_id',
   40        'tags',
   41    ]
   42
   43    def __init__(
   44        self,
   45        bind_interface=None,
   46        certificate_authority=None,
   47        client_certificate=None,
   48        client_key=None,
   49        egress_filter=None,
   50        healthcheck_namespace=None,
   51        healthy=None,
   52        hostname=None,
   53        id=None,
   54        name=None,
   55        port=None,
   56        remote_identity_group_id=None,
   57        remote_identity_healthcheck_username=None,
   58        secret_store_id=None,
   59        tags=None,
   60    ):
   61        self.bind_interface = bind_interface if bind_interface is not None else ''
   62        '''
   63         Bind interface
   64        '''
   65        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
   66        '''
   67
   68        '''
   69        self.client_certificate = client_certificate if client_certificate is not None else ''
   70        '''
   71
   72        '''
   73        self.client_key = client_key if client_key is not None else ''
   74        '''
   75
   76        '''
   77        self.egress_filter = egress_filter if egress_filter is not None else ''
   78        '''
   79         A filter applied to the routing logic to pin datasource to nodes.
   80        '''
   81        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
   82        '''
   83         The path used to check the health of your connection.  Defaults to `default`.
   84        '''
   85        self.healthy = healthy if healthy is not None else False
   86        '''
   87         True if the datasource is reachable and the credentials are valid.
   88        '''
   89        self.hostname = hostname if hostname is not None else ''
   90        '''
   91
   92        '''
   93        self.id = id if id is not None else ''
   94        '''
   95         Unique identifier of the Resource.
   96        '''
   97        self.name = name if name is not None else ''
   98        '''
   99         Unique human-readable name of the Resource.
  100        '''
  101        self.port = port if port is not None else 0
  102        '''
  103
  104        '''
  105        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
  106        '''
  107
  108        '''
  109        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
  110        '''
  111
  112        '''
  113        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
  114        '''
  115         ID of the secret store containing credentials for this resource, if any.
  116        '''
  117        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
  118        '''
  119         Tags is a map of key, value pairs.
  120        '''
  121
  122    def __repr__(self):
  123        return '<sdm.AKS ' + \
  124            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
  125            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
  126            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
  127            'client_key: ' + repr(self.client_key) + ' ' +\
  128            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
  129            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
  130            'healthy: ' + repr(self.healthy) + ' ' +\
  131            'hostname: ' + repr(self.hostname) + ' ' +\
  132            'id: ' + repr(self.id) + ' ' +\
  133            'name: ' + repr(self.name) + ' ' +\
  134            'port: ' + repr(self.port) + ' ' +\
  135            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
  136            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
  137            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
  138            'tags: ' + repr(self.tags) + ' ' +\
  139            '>'
  140
  141    def to_dict(self):
  142        return {
  143            'bind_interface': self.bind_interface,
  144            'certificate_authority': self.certificate_authority,
  145            'client_certificate': self.client_certificate,
  146            'client_key': self.client_key,
  147            'egress_filter': self.egress_filter,
  148            'healthcheck_namespace': self.healthcheck_namespace,
  149            'healthy': self.healthy,
  150            'hostname': self.hostname,
  151            'id': self.id,
  152            'name': self.name,
  153            'port': self.port,
  154            'remote_identity_group_id': self.remote_identity_group_id,
  155            'remote_identity_healthcheck_username':
  156            self.remote_identity_healthcheck_username,
  157            'secret_store_id': self.secret_store_id,
  158            'tags': self.tags,
  159        }
  160
  161    @classmethod
  162    def from_dict(cls, d):
  163        return cls(
  164            bind_interface=d.get('bind_interface'),
  165            certificate_authority=d.get('certificate_authority'),
  166            client_certificate=d.get('client_certificate'),
  167            client_key=d.get('client_key'),
  168            egress_filter=d.get('egress_filter'),
  169            healthcheck_namespace=d.get('healthcheck_namespace'),
  170            healthy=d.get('healthy'),
  171            hostname=d.get('hostname'),
  172            id=d.get('id'),
  173            name=d.get('name'),
  174            port=d.get('port'),
  175            remote_identity_group_id=d.get('remote_identity_group_id'),
  176            remote_identity_healthcheck_username=d.get(
  177                'remote_identity_healthcheck_username'),
  178            secret_store_id=d.get('secret_store_id'),
  179            tags=d.get('tags'),
  180        )
  181
  182
  183class AKSBasicAuth:
  184    '''
  185
  186    '''
  187    __slots__ = [
  188        'bind_interface',
  189        'egress_filter',
  190        'healthcheck_namespace',
  191        'healthy',
  192        'hostname',
  193        'id',
  194        'name',
  195        'password',
  196        'port',
  197        'secret_store_id',
  198        'tags',
  199        'username',
  200    ]
  201
  202    def __init__(
  203        self,
  204        bind_interface=None,
  205        egress_filter=None,
  206        healthcheck_namespace=None,
  207        healthy=None,
  208        hostname=None,
  209        id=None,
  210        name=None,
  211        password=None,
  212        port=None,
  213        secret_store_id=None,
  214        tags=None,
  215        username=None,
  216    ):
  217        self.bind_interface = bind_interface if bind_interface is not None else ''
  218        '''
  219         Bind interface
  220        '''
  221        self.egress_filter = egress_filter if egress_filter is not None else ''
  222        '''
  223         A filter applied to the routing logic to pin datasource to nodes.
  224        '''
  225        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
  226        '''
  227         The path used to check the health of your connection.  Defaults to `default`.
  228        '''
  229        self.healthy = healthy if healthy is not None else False
  230        '''
  231         True if the datasource is reachable and the credentials are valid.
  232        '''
  233        self.hostname = hostname if hostname is not None else ''
  234        '''
  235
  236        '''
  237        self.id = id if id is not None else ''
  238        '''
  239         Unique identifier of the Resource.
  240        '''
  241        self.name = name if name is not None else ''
  242        '''
  243         Unique human-readable name of the Resource.
  244        '''
  245        self.password = password if password is not None else ''
  246        '''
  247
  248        '''
  249        self.port = port if port is not None else 0
  250        '''
  251
  252        '''
  253        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
  254        '''
  255         ID of the secret store containing credentials for this resource, if any.
  256        '''
  257        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
  258        '''
  259         Tags is a map of key, value pairs.
  260        '''
  261        self.username = username if username is not None else ''
  262        '''
  263
  264        '''
  265
  266    def __repr__(self):
  267        return '<sdm.AKSBasicAuth ' + \
  268            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
  269            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
  270            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
  271            'healthy: ' + repr(self.healthy) + ' ' +\
  272            'hostname: ' + repr(self.hostname) + ' ' +\
  273            'id: ' + repr(self.id) + ' ' +\
  274            'name: ' + repr(self.name) + ' ' +\
  275            'password: ' + repr(self.password) + ' ' +\
  276            'port: ' + repr(self.port) + ' ' +\
  277            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
  278            'tags: ' + repr(self.tags) + ' ' +\
  279            'username: ' + repr(self.username) + ' ' +\
  280            '>'
  281
  282    def to_dict(self):
  283        return {
  284            'bind_interface': self.bind_interface,
  285            'egress_filter': self.egress_filter,
  286            'healthcheck_namespace': self.healthcheck_namespace,
  287            'healthy': self.healthy,
  288            'hostname': self.hostname,
  289            'id': self.id,
  290            'name': self.name,
  291            'password': self.password,
  292            'port': self.port,
  293            'secret_store_id': self.secret_store_id,
  294            'tags': self.tags,
  295            'username': self.username,
  296        }
  297
  298    @classmethod
  299    def from_dict(cls, d):
  300        return cls(
  301            bind_interface=d.get('bind_interface'),
  302            egress_filter=d.get('egress_filter'),
  303            healthcheck_namespace=d.get('healthcheck_namespace'),
  304            healthy=d.get('healthy'),
  305            hostname=d.get('hostname'),
  306            id=d.get('id'),
  307            name=d.get('name'),
  308            password=d.get('password'),
  309            port=d.get('port'),
  310            secret_store_id=d.get('secret_store_id'),
  311            tags=d.get('tags'),
  312            username=d.get('username'),
  313        )
  314
  315
  316class AKSServiceAccount:
  317    '''
  318
  319    '''
  320    __slots__ = [
  321        'bind_interface',
  322        'egress_filter',
  323        'healthcheck_namespace',
  324        'healthy',
  325        'hostname',
  326        'id',
  327        'name',
  328        'port',
  329        'remote_identity_group_id',
  330        'remote_identity_healthcheck_username',
  331        'secret_store_id',
  332        'tags',
  333        'token',
  334    ]
  335
  336    def __init__(
  337        self,
  338        bind_interface=None,
  339        egress_filter=None,
  340        healthcheck_namespace=None,
  341        healthy=None,
  342        hostname=None,
  343        id=None,
  344        name=None,
  345        port=None,
  346        remote_identity_group_id=None,
  347        remote_identity_healthcheck_username=None,
  348        secret_store_id=None,
  349        tags=None,
  350        token=None,
  351    ):
  352        self.bind_interface = bind_interface if bind_interface is not None else ''
  353        '''
  354         Bind interface
  355        '''
  356        self.egress_filter = egress_filter if egress_filter is not None else ''
  357        '''
  358         A filter applied to the routing logic to pin datasource to nodes.
  359        '''
  360        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
  361        '''
  362         The path used to check the health of your connection.  Defaults to `default`.
  363        '''
  364        self.healthy = healthy if healthy is not None else False
  365        '''
  366         True if the datasource is reachable and the credentials are valid.
  367        '''
  368        self.hostname = hostname if hostname is not None else ''
  369        '''
  370
  371        '''
  372        self.id = id if id is not None else ''
  373        '''
  374         Unique identifier of the Resource.
  375        '''
  376        self.name = name if name is not None else ''
  377        '''
  378         Unique human-readable name of the Resource.
  379        '''
  380        self.port = port if port is not None else 0
  381        '''
  382
  383        '''
  384        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
  385        '''
  386
  387        '''
  388        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
  389        '''
  390
  391        '''
  392        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
  393        '''
  394         ID of the secret store containing credentials for this resource, if any.
  395        '''
  396        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
  397        '''
  398         Tags is a map of key, value pairs.
  399        '''
  400        self.token = token if token is not None else ''
  401        '''
  402
  403        '''
  404
  405    def __repr__(self):
  406        return '<sdm.AKSServiceAccount ' + \
  407            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
  408            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
  409            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
  410            'healthy: ' + repr(self.healthy) + ' ' +\
  411            'hostname: ' + repr(self.hostname) + ' ' +\
  412            'id: ' + repr(self.id) + ' ' +\
  413            'name: ' + repr(self.name) + ' ' +\
  414            'port: ' + repr(self.port) + ' ' +\
  415            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
  416            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
  417            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
  418            'tags: ' + repr(self.tags) + ' ' +\
  419            'token: ' + repr(self.token) + ' ' +\
  420            '>'
  421
  422    def to_dict(self):
  423        return {
  424            'bind_interface': self.bind_interface,
  425            'egress_filter': self.egress_filter,
  426            'healthcheck_namespace': self.healthcheck_namespace,
  427            'healthy': self.healthy,
  428            'hostname': self.hostname,
  429            'id': self.id,
  430            'name': self.name,
  431            'port': self.port,
  432            'remote_identity_group_id': self.remote_identity_group_id,
  433            'remote_identity_healthcheck_username':
  434            self.remote_identity_healthcheck_username,
  435            'secret_store_id': self.secret_store_id,
  436            'tags': self.tags,
  437            'token': self.token,
  438        }
  439
  440    @classmethod
  441    def from_dict(cls, d):
  442        return cls(
  443            bind_interface=d.get('bind_interface'),
  444            egress_filter=d.get('egress_filter'),
  445            healthcheck_namespace=d.get('healthcheck_namespace'),
  446            healthy=d.get('healthy'),
  447            hostname=d.get('hostname'),
  448            id=d.get('id'),
  449            name=d.get('name'),
  450            port=d.get('port'),
  451            remote_identity_group_id=d.get('remote_identity_group_id'),
  452            remote_identity_healthcheck_username=d.get(
  453                'remote_identity_healthcheck_username'),
  454            secret_store_id=d.get('secret_store_id'),
  455            tags=d.get('tags'),
  456            token=d.get('token'),
  457        )
  458
  459
  460class AKSServiceAccountUserImpersonation:
  461    '''
  462
  463    '''
  464    __slots__ = [
  465        'bind_interface',
  466        'egress_filter',
  467        'healthcheck_namespace',
  468        'healthy',
  469        'hostname',
  470        'id',
  471        'name',
  472        'port',
  473        'secret_store_id',
  474        'tags',
  475        'token',
  476    ]
  477
  478    def __init__(
  479        self,
  480        bind_interface=None,
  481        egress_filter=None,
  482        healthcheck_namespace=None,
  483        healthy=None,
  484        hostname=None,
  485        id=None,
  486        name=None,
  487        port=None,
  488        secret_store_id=None,
  489        tags=None,
  490        token=None,
  491    ):
  492        self.bind_interface = bind_interface if bind_interface is not None else ''
  493        '''
  494         Bind interface
  495        '''
  496        self.egress_filter = egress_filter if egress_filter is not None else ''
  497        '''
  498         A filter applied to the routing logic to pin datasource to nodes.
  499        '''
  500        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
  501        '''
  502         The path used to check the health of your connection.  Defaults to `default`.
  503        '''
  504        self.healthy = healthy if healthy is not None else False
  505        '''
  506         True if the datasource is reachable and the credentials are valid.
  507        '''
  508        self.hostname = hostname if hostname is not None else ''
  509        '''
  510
  511        '''
  512        self.id = id if id is not None else ''
  513        '''
  514         Unique identifier of the Resource.
  515        '''
  516        self.name = name if name is not None else ''
  517        '''
  518         Unique human-readable name of the Resource.
  519        '''
  520        self.port = port if port is not None else 0
  521        '''
  522
  523        '''
  524        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
  525        '''
  526         ID of the secret store containing credentials for this resource, if any.
  527        '''
  528        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
  529        '''
  530         Tags is a map of key, value pairs.
  531        '''
  532        self.token = token if token is not None else ''
  533        '''
  534
  535        '''
  536
  537    def __repr__(self):
  538        return '<sdm.AKSServiceAccountUserImpersonation ' + \
  539            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
  540            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
  541            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
  542            'healthy: ' + repr(self.healthy) + ' ' +\
  543            'hostname: ' + repr(self.hostname) + ' ' +\
  544            'id: ' + repr(self.id) + ' ' +\
  545            'name: ' + repr(self.name) + ' ' +\
  546            'port: ' + repr(self.port) + ' ' +\
  547            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
  548            'tags: ' + repr(self.tags) + ' ' +\
  549            'token: ' + repr(self.token) + ' ' +\
  550            '>'
  551
  552    def to_dict(self):
  553        return {
  554            'bind_interface': self.bind_interface,
  555            'egress_filter': self.egress_filter,
  556            'healthcheck_namespace': self.healthcheck_namespace,
  557            'healthy': self.healthy,
  558            'hostname': self.hostname,
  559            'id': self.id,
  560            'name': self.name,
  561            'port': self.port,
  562            'secret_store_id': self.secret_store_id,
  563            'tags': self.tags,
  564            'token': self.token,
  565        }
  566
  567    @classmethod
  568    def from_dict(cls, d):
  569        return cls(
  570            bind_interface=d.get('bind_interface'),
  571            egress_filter=d.get('egress_filter'),
  572            healthcheck_namespace=d.get('healthcheck_namespace'),
  573            healthy=d.get('healthy'),
  574            hostname=d.get('hostname'),
  575            id=d.get('id'),
  576            name=d.get('name'),
  577            port=d.get('port'),
  578            secret_store_id=d.get('secret_store_id'),
  579            tags=d.get('tags'),
  580            token=d.get('token'),
  581        )
  582
  583
  584class AKSUserImpersonation:
  585    '''
  586
  587    '''
  588    __slots__ = [
  589        'bind_interface',
  590        'certificate_authority',
  591        'client_certificate',
  592        'client_key',
  593        'egress_filter',
  594        'healthcheck_namespace',
  595        'healthy',
  596        'hostname',
  597        'id',
  598        'name',
  599        'port',
  600        'secret_store_id',
  601        'tags',
  602    ]
  603
  604    def __init__(
  605        self,
  606        bind_interface=None,
  607        certificate_authority=None,
  608        client_certificate=None,
  609        client_key=None,
  610        egress_filter=None,
  611        healthcheck_namespace=None,
  612        healthy=None,
  613        hostname=None,
  614        id=None,
  615        name=None,
  616        port=None,
  617        secret_store_id=None,
  618        tags=None,
  619    ):
  620        self.bind_interface = bind_interface if bind_interface is not None else ''
  621        '''
  622         Bind interface
  623        '''
  624        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
  625        '''
  626
  627        '''
  628        self.client_certificate = client_certificate if client_certificate is not None else ''
  629        '''
  630
  631        '''
  632        self.client_key = client_key if client_key is not None else ''
  633        '''
  634
  635        '''
  636        self.egress_filter = egress_filter if egress_filter is not None else ''
  637        '''
  638         A filter applied to the routing logic to pin datasource to nodes.
  639        '''
  640        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
  641        '''
  642         The path used to check the health of your connection.  Defaults to `default`.
  643        '''
  644        self.healthy = healthy if healthy is not None else False
  645        '''
  646         True if the datasource is reachable and the credentials are valid.
  647        '''
  648        self.hostname = hostname if hostname is not None else ''
  649        '''
  650
  651        '''
  652        self.id = id if id is not None else ''
  653        '''
  654         Unique identifier of the Resource.
  655        '''
  656        self.name = name if name is not None else ''
  657        '''
  658         Unique human-readable name of the Resource.
  659        '''
  660        self.port = port if port is not None else 0
  661        '''
  662
  663        '''
  664        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
  665        '''
  666         ID of the secret store containing credentials for this resource, if any.
  667        '''
  668        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
  669        '''
  670         Tags is a map of key, value pairs.
  671        '''
  672
  673    def __repr__(self):
  674        return '<sdm.AKSUserImpersonation ' + \
  675            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
  676            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
  677            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
  678            'client_key: ' + repr(self.client_key) + ' ' +\
  679            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
  680            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
  681            'healthy: ' + repr(self.healthy) + ' ' +\
  682            'hostname: ' + repr(self.hostname) + ' ' +\
  683            'id: ' + repr(self.id) + ' ' +\
  684            'name: ' + repr(self.name) + ' ' +\
  685            'port: ' + repr(self.port) + ' ' +\
  686            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
  687            'tags: ' + repr(self.tags) + ' ' +\
  688            '>'
  689
  690    def to_dict(self):
  691        return {
  692            'bind_interface': self.bind_interface,
  693            'certificate_authority': self.certificate_authority,
  694            'client_certificate': self.client_certificate,
  695            'client_key': self.client_key,
  696            'egress_filter': self.egress_filter,
  697            'healthcheck_namespace': self.healthcheck_namespace,
  698            'healthy': self.healthy,
  699            'hostname': self.hostname,
  700            'id': self.id,
  701            'name': self.name,
  702            'port': self.port,
  703            'secret_store_id': self.secret_store_id,
  704            'tags': self.tags,
  705        }
  706
  707    @classmethod
  708    def from_dict(cls, d):
  709        return cls(
  710            bind_interface=d.get('bind_interface'),
  711            certificate_authority=d.get('certificate_authority'),
  712            client_certificate=d.get('client_certificate'),
  713            client_key=d.get('client_key'),
  714            egress_filter=d.get('egress_filter'),
  715            healthcheck_namespace=d.get('healthcheck_namespace'),
  716            healthy=d.get('healthy'),
  717            hostname=d.get('hostname'),
  718            id=d.get('id'),
  719            name=d.get('name'),
  720            port=d.get('port'),
  721            secret_store_id=d.get('secret_store_id'),
  722            tags=d.get('tags'),
  723        )
  724
  725
  726class AWS:
  727    '''
  728
  729    '''
  730    __slots__ = [
  731        'access_key',
  732        'bind_interface',
  733        'egress_filter',
  734        'healthcheck_region',
  735        'healthy',
  736        'id',
  737        'name',
  738        'role_arn',
  739        'role_external_id',
  740        'secret_access_key',
  741        'secret_store_id',
  742        'tags',
  743    ]
  744
  745    def __init__(
  746        self,
  747        access_key=None,
  748        bind_interface=None,
  749        egress_filter=None,
  750        healthcheck_region=None,
  751        healthy=None,
  752        id=None,
  753        name=None,
  754        role_arn=None,
  755        role_external_id=None,
  756        secret_access_key=None,
  757        secret_store_id=None,
  758        tags=None,
  759    ):
  760        self.access_key = access_key if access_key is not None else ''
  761        '''
  762
  763        '''
  764        self.bind_interface = bind_interface if bind_interface is not None else ''
  765        '''
  766         Bind interface
  767        '''
  768        self.egress_filter = egress_filter if egress_filter is not None else ''
  769        '''
  770         A filter applied to the routing logic to pin datasource to nodes.
  771        '''
  772        self.healthcheck_region = healthcheck_region if healthcheck_region is not None else ''
  773        '''
  774
  775        '''
  776        self.healthy = healthy if healthy is not None else False
  777        '''
  778         True if the datasource is reachable and the credentials are valid.
  779        '''
  780        self.id = id if id is not None else ''
  781        '''
  782         Unique identifier of the Resource.
  783        '''
  784        self.name = name if name is not None else ''
  785        '''
  786         Unique human-readable name of the Resource.
  787        '''
  788        self.role_arn = role_arn if role_arn is not None else ''
  789        '''
  790
  791        '''
  792        self.role_external_id = role_external_id if role_external_id is not None else ''
  793        '''
  794
  795        '''
  796        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
  797        '''
  798
  799        '''
  800        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
  801        '''
  802         ID of the secret store containing credentials for this resource, if any.
  803        '''
  804        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
  805        '''
  806         Tags is a map of key, value pairs.
  807        '''
  808
  809    def __repr__(self):
  810        return '<sdm.AWS ' + \
  811            'access_key: ' + repr(self.access_key) + ' ' +\
  812            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
  813            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
  814            'healthcheck_region: ' + repr(self.healthcheck_region) + ' ' +\
  815            'healthy: ' + repr(self.healthy) + ' ' +\
  816            'id: ' + repr(self.id) + ' ' +\
  817            'name: ' + repr(self.name) + ' ' +\
  818            'role_arn: ' + repr(self.role_arn) + ' ' +\
  819            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
  820            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
  821            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
  822            'tags: ' + repr(self.tags) + ' ' +\
  823            '>'
  824
  825    def to_dict(self):
  826        return {
  827            'access_key': self.access_key,
  828            'bind_interface': self.bind_interface,
  829            'egress_filter': self.egress_filter,
  830            'healthcheck_region': self.healthcheck_region,
  831            'healthy': self.healthy,
  832            'id': self.id,
  833            'name': self.name,
  834            'role_arn': self.role_arn,
  835            'role_external_id': self.role_external_id,
  836            'secret_access_key': self.secret_access_key,
  837            'secret_store_id': self.secret_store_id,
  838            'tags': self.tags,
  839        }
  840
  841    @classmethod
  842    def from_dict(cls, d):
  843        return cls(
  844            access_key=d.get('access_key'),
  845            bind_interface=d.get('bind_interface'),
  846            egress_filter=d.get('egress_filter'),
  847            healthcheck_region=d.get('healthcheck_region'),
  848            healthy=d.get('healthy'),
  849            id=d.get('id'),
  850            name=d.get('name'),
  851            role_arn=d.get('role_arn'),
  852            role_external_id=d.get('role_external_id'),
  853            secret_access_key=d.get('secret_access_key'),
  854            secret_store_id=d.get('secret_store_id'),
  855            tags=d.get('tags'),
  856        )
  857
  858
  859class AWSStore:
  860    '''
  861
  862    '''
  863    __slots__ = [
  864        'id',
  865        'name',
  866        'region',
  867        'tags',
  868    ]
  869
  870    def __init__(
  871        self,
  872        id=None,
  873        name=None,
  874        region=None,
  875        tags=None,
  876    ):
  877        self.id = id if id is not None else ''
  878        '''
  879         Unique identifier of the SecretStore.
  880        '''
  881        self.name = name if name is not None else ''
  882        '''
  883         Unique human-readable name of the SecretStore.
  884        '''
  885        self.region = region if region is not None else ''
  886        '''
  887
  888        '''
  889        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
  890        '''
  891         Tags is a map of key, value pairs.
  892        '''
  893
  894    def __repr__(self):
  895        return '<sdm.AWSStore ' + \
  896            'id: ' + repr(self.id) + ' ' +\
  897            'name: ' + repr(self.name) + ' ' +\
  898            'region: ' + repr(self.region) + ' ' +\
  899            'tags: ' + repr(self.tags) + ' ' +\
  900            '>'
  901
  902    def to_dict(self):
  903        return {
  904            'id': self.id,
  905            'name': self.name,
  906            'region': self.region,
  907            'tags': self.tags,
  908        }
  909
  910    @classmethod
  911    def from_dict(cls, d):
  912        return cls(
  913            id=d.get('id'),
  914            name=d.get('name'),
  915            region=d.get('region'),
  916            tags=d.get('tags'),
  917        )
  918
  919
  920class AccountAttachment:
  921    '''
  922     AccountAttachments assign an account to a role.
  923    '''
  924    __slots__ = [
  925        'account_id',
  926        'id',
  927        'role_id',
  928    ]
  929
  930    def __init__(
  931        self,
  932        account_id=None,
  933        id=None,
  934        role_id=None,
  935    ):
  936        self.account_id = account_id if account_id is not None else ''
  937        '''
  938         The id of the account of this AccountAttachment.
  939        '''
  940        self.id = id if id is not None else ''
  941        '''
  942         Unique identifier of the AccountAttachment.
  943        '''
  944        self.role_id = role_id if role_id is not None else ''
  945        '''
  946         The id of the attached role of this AccountAttachment.
  947        '''
  948
  949    def __repr__(self):
  950        return '<sdm.AccountAttachment ' + \
  951            'account_id: ' + repr(self.account_id) + ' ' +\
  952            'id: ' + repr(self.id) + ' ' +\
  953            'role_id: ' + repr(self.role_id) + ' ' +\
  954            '>'
  955
  956    def to_dict(self):
  957        return {
  958            'account_id': self.account_id,
  959            'id': self.id,
  960            'role_id': self.role_id,
  961        }
  962
  963    @classmethod
  964    def from_dict(cls, d):
  965        return cls(
  966            account_id=d.get('account_id'),
  967            id=d.get('id'),
  968            role_id=d.get('role_id'),
  969        )
  970
  971
  972class AccountAttachmentCreateResponse:
  973    '''
  974     AccountAttachmentCreateResponse reports how the AccountAttachments were created in the system.
  975    '''
  976    __slots__ = [
  977        'account_attachment',
  978        'meta',
  979        'rate_limit',
  980    ]
  981
  982    def __init__(
  983        self,
  984        account_attachment=None,
  985        meta=None,
  986        rate_limit=None,
  987    ):
  988        self.account_attachment = account_attachment if account_attachment is not None else None
  989        '''
  990         The created AccountAttachment.
  991        '''
  992        self.meta = meta if meta is not None else None
  993        '''
  994         Reserved for future use.
  995        '''
  996        self.rate_limit = rate_limit if rate_limit is not None else None
  997        '''
  998         Rate limit information.
  999        '''
 1000
 1001    def __repr__(self):
 1002        return '<sdm.AccountAttachmentCreateResponse ' + \
 1003            'account_attachment: ' + repr(self.account_attachment) + ' ' +\
 1004            'meta: ' + repr(self.meta) + ' ' +\
 1005            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1006            '>'
 1007
 1008    def to_dict(self):
 1009        return {
 1010            'account_attachment': self.account_attachment,
 1011            'meta': self.meta,
 1012            'rate_limit': self.rate_limit,
 1013        }
 1014
 1015    @classmethod
 1016    def from_dict(cls, d):
 1017        return cls(
 1018            account_attachment=d.get('account_attachment'),
 1019            meta=d.get('meta'),
 1020            rate_limit=d.get('rate_limit'),
 1021        )
 1022
 1023
 1024class AccountAttachmentDeleteResponse:
 1025    '''
 1026     AccountAttachmentDeleteResponse returns information about a AccountAttachment that was deleted.
 1027    '''
 1028    __slots__ = [
 1029        'meta',
 1030        'rate_limit',
 1031    ]
 1032
 1033    def __init__(
 1034        self,
 1035        meta=None,
 1036        rate_limit=None,
 1037    ):
 1038        self.meta = meta if meta is not None else None
 1039        '''
 1040         Reserved for future use.
 1041        '''
 1042        self.rate_limit = rate_limit if rate_limit is not None else None
 1043        '''
 1044         Rate limit information.
 1045        '''
 1046
 1047    def __repr__(self):
 1048        return '<sdm.AccountAttachmentDeleteResponse ' + \
 1049            'meta: ' + repr(self.meta) + ' ' +\
 1050            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1051            '>'
 1052
 1053    def to_dict(self):
 1054        return {
 1055            'meta': self.meta,
 1056            'rate_limit': self.rate_limit,
 1057        }
 1058
 1059    @classmethod
 1060    def from_dict(cls, d):
 1061        return cls(
 1062            meta=d.get('meta'),
 1063            rate_limit=d.get('rate_limit'),
 1064        )
 1065
 1066
 1067class AccountAttachmentGetResponse:
 1068    '''
 1069     AccountAttachmentGetResponse returns a requested AccountAttachment.
 1070    '''
 1071    __slots__ = [
 1072        'account_attachment',
 1073        'meta',
 1074        'rate_limit',
 1075    ]
 1076
 1077    def __init__(
 1078        self,
 1079        account_attachment=None,
 1080        meta=None,
 1081        rate_limit=None,
 1082    ):
 1083        self.account_attachment = account_attachment if account_attachment is not None else None
 1084        '''
 1085         The requested AccountAttachment.
 1086        '''
 1087        self.meta = meta if meta is not None else None
 1088        '''
 1089         Reserved for future use.
 1090        '''
 1091        self.rate_limit = rate_limit if rate_limit is not None else None
 1092        '''
 1093         Rate limit information.
 1094        '''
 1095
 1096    def __repr__(self):
 1097        return '<sdm.AccountAttachmentGetResponse ' + \
 1098            'account_attachment: ' + repr(self.account_attachment) + ' ' +\
 1099            'meta: ' + repr(self.meta) + ' ' +\
 1100            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1101            '>'
 1102
 1103    def to_dict(self):
 1104        return {
 1105            'account_attachment': self.account_attachment,
 1106            'meta': self.meta,
 1107            'rate_limit': self.rate_limit,
 1108        }
 1109
 1110    @classmethod
 1111    def from_dict(cls, d):
 1112        return cls(
 1113            account_attachment=d.get('account_attachment'),
 1114            meta=d.get('meta'),
 1115            rate_limit=d.get('rate_limit'),
 1116        )
 1117
 1118
 1119class AccountCreateResponse:
 1120    '''
 1121     AccountCreateResponse reports how the Accounts were created in the system.
 1122    '''
 1123    __slots__ = [
 1124        'account',
 1125        'meta',
 1126        'rate_limit',
 1127        'token',
 1128    ]
 1129
 1130    def __init__(
 1131        self,
 1132        account=None,
 1133        meta=None,
 1134        rate_limit=None,
 1135        token=None,
 1136    ):
 1137        self.account = account if account is not None else None
 1138        '''
 1139         The created Account.
 1140        '''
 1141        self.meta = meta if meta is not None else None
 1142        '''
 1143         Reserved for future use.
 1144        '''
 1145        self.rate_limit = rate_limit if rate_limit is not None else None
 1146        '''
 1147         Rate limit information.
 1148        '''
 1149        self.token = token if token is not None else ''
 1150        '''
 1151         The auth token generated for the Account. The Account will use this token to
 1152         authenticate with the strongDM API.
 1153        '''
 1154
 1155    def __repr__(self):
 1156        return '<sdm.AccountCreateResponse ' + \
 1157            'account: ' + repr(self.account) + ' ' +\
 1158            'meta: ' + repr(self.meta) + ' ' +\
 1159            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1160            'token: ' + repr(self.token) + ' ' +\
 1161            '>'
 1162
 1163    def to_dict(self):
 1164        return {
 1165            'account': self.account,
 1166            'meta': self.meta,
 1167            'rate_limit': self.rate_limit,
 1168            'token': self.token,
 1169        }
 1170
 1171    @classmethod
 1172    def from_dict(cls, d):
 1173        return cls(
 1174            account=d.get('account'),
 1175            meta=d.get('meta'),
 1176            rate_limit=d.get('rate_limit'),
 1177            token=d.get('token'),
 1178        )
 1179
 1180
 1181class AccountDeleteResponse:
 1182    '''
 1183     AccountDeleteResponse returns information about a Account that was deleted.
 1184    '''
 1185    __slots__ = [
 1186        'meta',
 1187        'rate_limit',
 1188    ]
 1189
 1190    def __init__(
 1191        self,
 1192        meta=None,
 1193        rate_limit=None,
 1194    ):
 1195        self.meta = meta if meta is not None else None
 1196        '''
 1197         Reserved for future use.
 1198        '''
 1199        self.rate_limit = rate_limit if rate_limit is not None else None
 1200        '''
 1201         Rate limit information.
 1202        '''
 1203
 1204    def __repr__(self):
 1205        return '<sdm.AccountDeleteResponse ' + \
 1206            'meta: ' + repr(self.meta) + ' ' +\
 1207            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1208            '>'
 1209
 1210    def to_dict(self):
 1211        return {
 1212            'meta': self.meta,
 1213            'rate_limit': self.rate_limit,
 1214        }
 1215
 1216    @classmethod
 1217    def from_dict(cls, d):
 1218        return cls(
 1219            meta=d.get('meta'),
 1220            rate_limit=d.get('rate_limit'),
 1221        )
 1222
 1223
 1224class AccountGetResponse:
 1225    '''
 1226     AccountGetResponse returns a requested Account.
 1227    '''
 1228    __slots__ = [
 1229        'account',
 1230        'meta',
 1231        'rate_limit',
 1232    ]
 1233
 1234    def __init__(
 1235        self,
 1236        account=None,
 1237        meta=None,
 1238        rate_limit=None,
 1239    ):
 1240        self.account = account if account is not None else None
 1241        '''
 1242         The requested Account.
 1243        '''
 1244        self.meta = meta if meta is not None else None
 1245        '''
 1246         Reserved for future use.
 1247        '''
 1248        self.rate_limit = rate_limit if rate_limit is not None else None
 1249        '''
 1250         Rate limit information.
 1251        '''
 1252
 1253    def __repr__(self):
 1254        return '<sdm.AccountGetResponse ' + \
 1255            'account: ' + repr(self.account) + ' ' +\
 1256            'meta: ' + repr(self.meta) + ' ' +\
 1257            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1258            '>'
 1259
 1260    def to_dict(self):
 1261        return {
 1262            'account': self.account,
 1263            'meta': self.meta,
 1264            'rate_limit': self.rate_limit,
 1265        }
 1266
 1267    @classmethod
 1268    def from_dict(cls, d):
 1269        return cls(
 1270            account=d.get('account'),
 1271            meta=d.get('meta'),
 1272            rate_limit=d.get('rate_limit'),
 1273        )
 1274
 1275
 1276class AccountGrant:
 1277    '''
 1278     AccountGrants connect a resource directly to an account, giving the account the permission to connect to that resource.
 1279    '''
 1280    __slots__ = [
 1281        'account_id',
 1282        'id',
 1283        'resource_id',
 1284        'start_from',
 1285        'valid_until',
 1286    ]
 1287
 1288    def __init__(
 1289        self,
 1290        account_id=None,
 1291        id=None,
 1292        resource_id=None,
 1293        start_from=None,
 1294        valid_until=None,
 1295    ):
 1296        self.account_id = account_id if account_id is not None else ''
 1297        '''
 1298         The account id of this AccountGrant.
 1299        '''
 1300        self.id = id if id is not None else ''
 1301        '''
 1302         Unique identifier of the AccountGrant.
 1303        '''
 1304        self.resource_id = resource_id if resource_id is not None else ''
 1305        '''
 1306         The resource id of this AccountGrant.
 1307        '''
 1308        self.start_from = start_from if start_from is not None else None
 1309        '''
 1310         The timestamp when the resource will be granted. Optional. Both start_at
 1311         and end_at must be defined together, or not defined at all.
 1312        '''
 1313        self.valid_until = valid_until if valid_until is not None else None
 1314        '''
 1315         The timestamp when the resource grant will expire. Optional. Both
 1316         start_at and end_at must be defined together, or not defined at all.
 1317        '''
 1318
 1319    def __repr__(self):
 1320        return '<sdm.AccountGrant ' + \
 1321            'account_id: ' + repr(self.account_id) + ' ' +\
 1322            'id: ' + repr(self.id) + ' ' +\
 1323            'resource_id: ' + repr(self.resource_id) + ' ' +\
 1324            'start_from: ' + repr(self.start_from) + ' ' +\
 1325            'valid_until: ' + repr(self.valid_until) + ' ' +\
 1326            '>'
 1327
 1328    def to_dict(self):
 1329        return {
 1330            'account_id': self.account_id,
 1331            'id': self.id,
 1332            'resource_id': self.resource_id,
 1333            'start_from': self.start_from,
 1334            'valid_until': self.valid_until,
 1335        }
 1336
 1337    @classmethod
 1338    def from_dict(cls, d):
 1339        return cls(
 1340            account_id=d.get('account_id'),
 1341            id=d.get('id'),
 1342            resource_id=d.get('resource_id'),
 1343            start_from=d.get('start_from'),
 1344            valid_until=d.get('valid_until'),
 1345        )
 1346
 1347
 1348class AccountGrantCreateResponse:
 1349    '''
 1350     AccountGrantCreateResponse reports how the AccountGrants were created in the system.
 1351    '''
 1352    __slots__ = [
 1353        'account_grant',
 1354        'meta',
 1355        'rate_limit',
 1356    ]
 1357
 1358    def __init__(
 1359        self,
 1360        account_grant=None,
 1361        meta=None,
 1362        rate_limit=None,
 1363    ):
 1364        self.account_grant = account_grant if account_grant is not None else None
 1365        '''
 1366         The created AccountGrant.
 1367        '''
 1368        self.meta = meta if meta is not None else None
 1369        '''
 1370         Reserved for future use.
 1371        '''
 1372        self.rate_limit = rate_limit if rate_limit is not None else None
 1373        '''
 1374         Rate limit information.
 1375        '''
 1376
 1377    def __repr__(self):
 1378        return '<sdm.AccountGrantCreateResponse ' + \
 1379            'account_grant: ' + repr(self.account_grant) + ' ' +\
 1380            'meta: ' + repr(self.meta) + ' ' +\
 1381            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1382            '>'
 1383
 1384    def to_dict(self):
 1385        return {
 1386            'account_grant': self.account_grant,
 1387            'meta': self.meta,
 1388            'rate_limit': self.rate_limit,
 1389        }
 1390
 1391    @classmethod
 1392    def from_dict(cls, d):
 1393        return cls(
 1394            account_grant=d.get('account_grant'),
 1395            meta=d.get('meta'),
 1396            rate_limit=d.get('rate_limit'),
 1397        )
 1398
 1399
 1400class AccountGrantDeleteResponse:
 1401    '''
 1402     AccountGrantDeleteResponse returns information about a AccountGrant that was deleted.
 1403    '''
 1404    __slots__ = [
 1405        'meta',
 1406        'rate_limit',
 1407    ]
 1408
 1409    def __init__(
 1410        self,
 1411        meta=None,
 1412        rate_limit=None,
 1413    ):
 1414        self.meta = meta if meta is not None else None
 1415        '''
 1416         Reserved for future use.
 1417        '''
 1418        self.rate_limit = rate_limit if rate_limit is not None else None
 1419        '''
 1420         Rate limit information.
 1421        '''
 1422
 1423    def __repr__(self):
 1424        return '<sdm.AccountGrantDeleteResponse ' + \
 1425            'meta: ' + repr(self.meta) + ' ' +\
 1426            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1427            '>'
 1428
 1429    def to_dict(self):
 1430        return {
 1431            'meta': self.meta,
 1432            'rate_limit': self.rate_limit,
 1433        }
 1434
 1435    @classmethod
 1436    def from_dict(cls, d):
 1437        return cls(
 1438            meta=d.get('meta'),
 1439            rate_limit=d.get('rate_limit'),
 1440        )
 1441
 1442
 1443class AccountGrantGetResponse:
 1444    '''
 1445     AccountGrantGetResponse returns a requested AccountGrant.
 1446    '''
 1447    __slots__ = [
 1448        'account_grant',
 1449        'meta',
 1450        'rate_limit',
 1451    ]
 1452
 1453    def __init__(
 1454        self,
 1455        account_grant=None,
 1456        meta=None,
 1457        rate_limit=None,
 1458    ):
 1459        self.account_grant = account_grant if account_grant is not None else None
 1460        '''
 1461         The requested AccountGrant.
 1462        '''
 1463        self.meta = meta if meta is not None else None
 1464        '''
 1465         Reserved for future use.
 1466        '''
 1467        self.rate_limit = rate_limit if rate_limit is not None else None
 1468        '''
 1469         Rate limit information.
 1470        '''
 1471
 1472    def __repr__(self):
 1473        return '<sdm.AccountGrantGetResponse ' + \
 1474            'account_grant: ' + repr(self.account_grant) + ' ' +\
 1475            'meta: ' + repr(self.meta) + ' ' +\
 1476            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1477            '>'
 1478
 1479    def to_dict(self):
 1480        return {
 1481            'account_grant': self.account_grant,
 1482            'meta': self.meta,
 1483            'rate_limit': self.rate_limit,
 1484        }
 1485
 1486    @classmethod
 1487    def from_dict(cls, d):
 1488        return cls(
 1489            account_grant=d.get('account_grant'),
 1490            meta=d.get('meta'),
 1491            rate_limit=d.get('rate_limit'),
 1492        )
 1493
 1494
 1495class AccountUpdateResponse:
 1496    '''
 1497     AccountUpdateResponse returns the fields of a Account after it has been updated by
 1498     a AccountUpdateRequest.
 1499    '''
 1500    __slots__ = [
 1501        'account',
 1502        'meta',
 1503        'rate_limit',
 1504    ]
 1505
 1506    def __init__(
 1507        self,
 1508        account=None,
 1509        meta=None,
 1510        rate_limit=None,
 1511    ):
 1512        self.account = account if account is not None else None
 1513        '''
 1514         The updated Account.
 1515        '''
 1516        self.meta = meta if meta is not None else None
 1517        '''
 1518         Reserved for future use.
 1519        '''
 1520        self.rate_limit = rate_limit if rate_limit is not None else None
 1521        '''
 1522         Rate limit information.
 1523        '''
 1524
 1525    def __repr__(self):
 1526        return '<sdm.AccountUpdateResponse ' + \
 1527            'account: ' + repr(self.account) + ' ' +\
 1528            'meta: ' + repr(self.meta) + ' ' +\
 1529            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 1530            '>'
 1531
 1532    def to_dict(self):
 1533        return {
 1534            'account': self.account,
 1535            'meta': self.meta,
 1536            'rate_limit': self.rate_limit,
 1537        }
 1538
 1539    @classmethod
 1540    def from_dict(cls, d):
 1541        return cls(
 1542            account=d.get('account'),
 1543            meta=d.get('meta'),
 1544            rate_limit=d.get('rate_limit'),
 1545        )
 1546
 1547
 1548class AmazonEKS:
 1549    '''
 1550
 1551    '''
 1552    __slots__ = [
 1553        'access_key',
 1554        'bind_interface',
 1555        'certificate_authority',
 1556        'cluster_name',
 1557        'egress_filter',
 1558        'endpoint',
 1559        'healthcheck_namespace',
 1560        'healthy',
 1561        'id',
 1562        'name',
 1563        'region',
 1564        'remote_identity_group_id',
 1565        'remote_identity_healthcheck_username',
 1566        'role_arn',
 1567        'role_external_id',
 1568        'secret_access_key',
 1569        'secret_store_id',
 1570        'tags',
 1571    ]
 1572
 1573    def __init__(
 1574        self,
 1575        access_key=None,
 1576        bind_interface=None,
 1577        certificate_authority=None,
 1578        cluster_name=None,
 1579        egress_filter=None,
 1580        endpoint=None,
 1581        healthcheck_namespace=None,
 1582        healthy=None,
 1583        id=None,
 1584        name=None,
 1585        region=None,
 1586        remote_identity_group_id=None,
 1587        remote_identity_healthcheck_username=None,
 1588        role_arn=None,
 1589        role_external_id=None,
 1590        secret_access_key=None,
 1591        secret_store_id=None,
 1592        tags=None,
 1593    ):
 1594        self.access_key = access_key if access_key is not None else ''
 1595        '''
 1596
 1597        '''
 1598        self.bind_interface = bind_interface if bind_interface is not None else ''
 1599        '''
 1600         Bind interface
 1601        '''
 1602        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 1603        '''
 1604
 1605        '''
 1606        self.cluster_name = cluster_name if cluster_name is not None else ''
 1607        '''
 1608
 1609        '''
 1610        self.egress_filter = egress_filter if egress_filter is not None else ''
 1611        '''
 1612         A filter applied to the routing logic to pin datasource to nodes.
 1613        '''
 1614        self.endpoint = endpoint if endpoint is not None else ''
 1615        '''
 1616
 1617        '''
 1618        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 1619        '''
 1620         The path used to check the health of your connection.  Defaults to `default`.
 1621        '''
 1622        self.healthy = healthy if healthy is not None else False
 1623        '''
 1624         True if the datasource is reachable and the credentials are valid.
 1625        '''
 1626        self.id = id if id is not None else ''
 1627        '''
 1628         Unique identifier of the Resource.
 1629        '''
 1630        self.name = name if name is not None else ''
 1631        '''
 1632         Unique human-readable name of the Resource.
 1633        '''
 1634        self.region = region if region is not None else ''
 1635        '''
 1636
 1637        '''
 1638        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
 1639        '''
 1640
 1641        '''
 1642        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
 1643        '''
 1644
 1645        '''
 1646        self.role_arn = role_arn if role_arn is not None else ''
 1647        '''
 1648
 1649        '''
 1650        self.role_external_id = role_external_id if role_external_id is not None else ''
 1651        '''
 1652
 1653        '''
 1654        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
 1655        '''
 1656
 1657        '''
 1658        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 1659        '''
 1660         ID of the secret store containing credentials for this resource, if any.
 1661        '''
 1662        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 1663        '''
 1664         Tags is a map of key, value pairs.
 1665        '''
 1666
 1667    def __repr__(self):
 1668        return '<sdm.AmazonEKS ' + \
 1669            'access_key: ' + repr(self.access_key) + ' ' +\
 1670            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 1671            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
 1672            'cluster_name: ' + repr(self.cluster_name) + ' ' +\
 1673            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 1674            'endpoint: ' + repr(self.endpoint) + ' ' +\
 1675            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 1676            'healthy: ' + repr(self.healthy) + ' ' +\
 1677            'id: ' + repr(self.id) + ' ' +\
 1678            'name: ' + repr(self.name) + ' ' +\
 1679            'region: ' + repr(self.region) + ' ' +\
 1680            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
 1681            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
 1682            'role_arn: ' + repr(self.role_arn) + ' ' +\
 1683            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
 1684            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
 1685            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 1686            'tags: ' + repr(self.tags) + ' ' +\
 1687            '>'
 1688
 1689    def to_dict(self):
 1690        return {
 1691            'access_key': self.access_key,
 1692            'bind_interface': self.bind_interface,
 1693            'certificate_authority': self.certificate_authority,
 1694            'cluster_name': self.cluster_name,
 1695            'egress_filter': self.egress_filter,
 1696            'endpoint': self.endpoint,
 1697            'healthcheck_namespace': self.healthcheck_namespace,
 1698            'healthy': self.healthy,
 1699            'id': self.id,
 1700            'name': self.name,
 1701            'region': self.region,
 1702            'remote_identity_group_id': self.remote_identity_group_id,
 1703            'remote_identity_healthcheck_username':
 1704            self.remote_identity_healthcheck_username,
 1705            'role_arn': self.role_arn,
 1706            'role_external_id': self.role_external_id,
 1707            'secret_access_key': self.secret_access_key,
 1708            'secret_store_id': self.secret_store_id,
 1709            'tags': self.tags,
 1710        }
 1711
 1712    @classmethod
 1713    def from_dict(cls, d):
 1714        return cls(
 1715            access_key=d.get('access_key'),
 1716            bind_interface=d.get('bind_interface'),
 1717            certificate_authority=d.get('certificate_authority'),
 1718            cluster_name=d.get('cluster_name'),
 1719            egress_filter=d.get('egress_filter'),
 1720            endpoint=d.get('endpoint'),
 1721            healthcheck_namespace=d.get('healthcheck_namespace'),
 1722            healthy=d.get('healthy'),
 1723            id=d.get('id'),
 1724            name=d.get('name'),
 1725            region=d.get('region'),
 1726            remote_identity_group_id=d.get('remote_identity_group_id'),
 1727            remote_identity_healthcheck_username=d.get(
 1728                'remote_identity_healthcheck_username'),
 1729            role_arn=d.get('role_arn'),
 1730            role_external_id=d.get('role_external_id'),
 1731            secret_access_key=d.get('secret_access_key'),
 1732            secret_store_id=d.get('secret_store_id'),
 1733            tags=d.get('tags'),
 1734        )
 1735
 1736
 1737class AmazonEKSUserImpersonation:
 1738    '''
 1739
 1740    '''
 1741    __slots__ = [
 1742        'access_key',
 1743        'bind_interface',
 1744        'certificate_authority',
 1745        'cluster_name',
 1746        'egress_filter',
 1747        'endpoint',
 1748        'healthcheck_namespace',
 1749        'healthy',
 1750        'id',
 1751        'name',
 1752        'region',
 1753        'role_arn',
 1754        'role_external_id',
 1755        'secret_access_key',
 1756        'secret_store_id',
 1757        'tags',
 1758    ]
 1759
 1760    def __init__(
 1761        self,
 1762        access_key=None,
 1763        bind_interface=None,
 1764        certificate_authority=None,
 1765        cluster_name=None,
 1766        egress_filter=None,
 1767        endpoint=None,
 1768        healthcheck_namespace=None,
 1769        healthy=None,
 1770        id=None,
 1771        name=None,
 1772        region=None,
 1773        role_arn=None,
 1774        role_external_id=None,
 1775        secret_access_key=None,
 1776        secret_store_id=None,
 1777        tags=None,
 1778    ):
 1779        self.access_key = access_key if access_key is not None else ''
 1780        '''
 1781
 1782        '''
 1783        self.bind_interface = bind_interface if bind_interface is not None else ''
 1784        '''
 1785         Bind interface
 1786        '''
 1787        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 1788        '''
 1789
 1790        '''
 1791        self.cluster_name = cluster_name if cluster_name is not None else ''
 1792        '''
 1793
 1794        '''
 1795        self.egress_filter = egress_filter if egress_filter is not None else ''
 1796        '''
 1797         A filter applied to the routing logic to pin datasource to nodes.
 1798        '''
 1799        self.endpoint = endpoint if endpoint is not None else ''
 1800        '''
 1801
 1802        '''
 1803        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 1804        '''
 1805         The path used to check the health of your connection.  Defaults to `default`.
 1806        '''
 1807        self.healthy = healthy if healthy is not None else False
 1808        '''
 1809         True if the datasource is reachable and the credentials are valid.
 1810        '''
 1811        self.id = id if id is not None else ''
 1812        '''
 1813         Unique identifier of the Resource.
 1814        '''
 1815        self.name = name if name is not None else ''
 1816        '''
 1817         Unique human-readable name of the Resource.
 1818        '''
 1819        self.region = region if region is not None else ''
 1820        '''
 1821
 1822        '''
 1823        self.role_arn = role_arn if role_arn is not None else ''
 1824        '''
 1825
 1826        '''
 1827        self.role_external_id = role_external_id if role_external_id is not None else ''
 1828        '''
 1829
 1830        '''
 1831        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
 1832        '''
 1833
 1834        '''
 1835        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 1836        '''
 1837         ID of the secret store containing credentials for this resource, if any.
 1838        '''
 1839        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 1840        '''
 1841         Tags is a map of key, value pairs.
 1842        '''
 1843
 1844    def __repr__(self):
 1845        return '<sdm.AmazonEKSUserImpersonation ' + \
 1846            'access_key: ' + repr(self.access_key) + ' ' +\
 1847            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 1848            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
 1849            'cluster_name: ' + repr(self.cluster_name) + ' ' +\
 1850            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 1851            'endpoint: ' + repr(self.endpoint) + ' ' +\
 1852            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 1853            'healthy: ' + repr(self.healthy) + ' ' +\
 1854            'id: ' + repr(self.id) + ' ' +\
 1855            'name: ' + repr(self.name) + ' ' +\
 1856            'region: ' + repr(self.region) + ' ' +\
 1857            'role_arn: ' + repr(self.role_arn) + ' ' +\
 1858            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
 1859            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
 1860            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 1861            'tags: ' + repr(self.tags) + ' ' +\
 1862            '>'
 1863
 1864    def to_dict(self):
 1865        return {
 1866            'access_key': self.access_key,
 1867            'bind_interface': self.bind_interface,
 1868            'certificate_authority': self.certificate_authority,
 1869            'cluster_name': self.cluster_name,
 1870            'egress_filter': self.egress_filter,
 1871            'endpoint': self.endpoint,
 1872            'healthcheck_namespace': self.healthcheck_namespace,
 1873            'healthy': self.healthy,
 1874            'id': self.id,
 1875            'name': self.name,
 1876            'region': self.region,
 1877            'role_arn': self.role_arn,
 1878            'role_external_id': self.role_external_id,
 1879            'secret_access_key': self.secret_access_key,
 1880            'secret_store_id': self.secret_store_id,
 1881            'tags': self.tags,
 1882        }
 1883
 1884    @classmethod
 1885    def from_dict(cls, d):
 1886        return cls(
 1887            access_key=d.get('access_key'),
 1888            bind_interface=d.get('bind_interface'),
 1889            certificate_authority=d.get('certificate_authority'),
 1890            cluster_name=d.get('cluster_name'),
 1891            egress_filter=d.get('egress_filter'),
 1892            endpoint=d.get('endpoint'),
 1893            healthcheck_namespace=d.get('healthcheck_namespace'),
 1894            healthy=d.get('healthy'),
 1895            id=d.get('id'),
 1896            name=d.get('name'),
 1897            region=d.get('region'),
 1898            role_arn=d.get('role_arn'),
 1899            role_external_id=d.get('role_external_id'),
 1900            secret_access_key=d.get('secret_access_key'),
 1901            secret_store_id=d.get('secret_store_id'),
 1902            tags=d.get('tags'),
 1903        )
 1904
 1905
 1906class AmazonES:
 1907    '''
 1908
 1909    '''
 1910    __slots__ = [
 1911        'access_key',
 1912        'bind_interface',
 1913        'egress_filter',
 1914        'endpoint',
 1915        'healthy',
 1916        'id',
 1917        'name',
 1918        'port_override',
 1919        'region',
 1920        'role_arn',
 1921        'role_external_id',
 1922        'secret_access_key',
 1923        'secret_store_id',
 1924        'tags',
 1925    ]
 1926
 1927    def __init__(
 1928        self,
 1929        access_key=None,
 1930        bind_interface=None,
 1931        egress_filter=None,
 1932        endpoint=None,
 1933        healthy=None,
 1934        id=None,
 1935        name=None,
 1936        port_override=None,
 1937        region=None,
 1938        role_arn=None,
 1939        role_external_id=None,
 1940        secret_access_key=None,
 1941        secret_store_id=None,
 1942        tags=None,
 1943    ):
 1944        self.access_key = access_key if access_key is not None else ''
 1945        '''
 1946
 1947        '''
 1948        self.bind_interface = bind_interface if bind_interface is not None else ''
 1949        '''
 1950         Bind interface
 1951        '''
 1952        self.egress_filter = egress_filter if egress_filter is not None else ''
 1953        '''
 1954         A filter applied to the routing logic to pin datasource to nodes.
 1955        '''
 1956        self.endpoint = endpoint if endpoint is not None else ''
 1957        '''
 1958
 1959        '''
 1960        self.healthy = healthy if healthy is not None else False
 1961        '''
 1962         True if the datasource is reachable and the credentials are valid.
 1963        '''
 1964        self.id = id if id is not None else ''
 1965        '''
 1966         Unique identifier of the Resource.
 1967        '''
 1968        self.name = name if name is not None else ''
 1969        '''
 1970         Unique human-readable name of the Resource.
 1971        '''
 1972        self.port_override = port_override if port_override is not None else 0
 1973        '''
 1974
 1975        '''
 1976        self.region = region if region is not None else ''
 1977        '''
 1978
 1979        '''
 1980        self.role_arn = role_arn if role_arn is not None else ''
 1981        '''
 1982
 1983        '''
 1984        self.role_external_id = role_external_id if role_external_id is not None else ''
 1985        '''
 1986
 1987        '''
 1988        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
 1989        '''
 1990
 1991        '''
 1992        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 1993        '''
 1994         ID of the secret store containing credentials for this resource, if any.
 1995        '''
 1996        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 1997        '''
 1998         Tags is a map of key, value pairs.
 1999        '''
 2000
 2001    def __repr__(self):
 2002        return '<sdm.AmazonES ' + \
 2003            'access_key: ' + repr(self.access_key) + ' ' +\
 2004            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 2005            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 2006            'endpoint: ' + repr(self.endpoint) + ' ' +\
 2007            'healthy: ' + repr(self.healthy) + ' ' +\
 2008            'id: ' + repr(self.id) + ' ' +\
 2009            'name: ' + repr(self.name) + ' ' +\
 2010            'port_override: ' + repr(self.port_override) + ' ' +\
 2011            'region: ' + repr(self.region) + ' ' +\
 2012            'role_arn: ' + repr(self.role_arn) + ' ' +\
 2013            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
 2014            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
 2015            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 2016            'tags: ' + repr(self.tags) + ' ' +\
 2017            '>'
 2018
 2019    def to_dict(self):
 2020        return {
 2021            'access_key': self.access_key,
 2022            'bind_interface': self.bind_interface,
 2023            'egress_filter': self.egress_filter,
 2024            'endpoint': self.endpoint,
 2025            'healthy': self.healthy,
 2026            'id': self.id,
 2027            'name': self.name,
 2028            'port_override': self.port_override,
 2029            'region': self.region,
 2030            'role_arn': self.role_arn,
 2031            'role_external_id': self.role_external_id,
 2032            'secret_access_key': self.secret_access_key,
 2033            'secret_store_id': self.secret_store_id,
 2034            'tags': self.tags,
 2035        }
 2036
 2037    @classmethod
 2038    def from_dict(cls, d):
 2039        return cls(
 2040            access_key=d.get('access_key'),
 2041            bind_interface=d.get('bind_interface'),
 2042            egress_filter=d.get('egress_filter'),
 2043            endpoint=d.get('endpoint'),
 2044            healthy=d.get('healthy'),
 2045            id=d.get('id'),
 2046            name=d.get('name'),
 2047            port_override=d.get('port_override'),
 2048            region=d.get('region'),
 2049            role_arn=d.get('role_arn'),
 2050            role_external_id=d.get('role_external_id'),
 2051            secret_access_key=d.get('secret_access_key'),
 2052            secret_store_id=d.get('secret_store_id'),
 2053            tags=d.get('tags'),
 2054        )
 2055
 2056
 2057class AmazonMQAMQP091:
 2058    '''
 2059
 2060    '''
 2061    __slots__ = [
 2062        'bind_interface',
 2063        'egress_filter',
 2064        'healthy',
 2065        'hostname',
 2066        'id',
 2067        'name',
 2068        'password',
 2069        'port',
 2070        'port_override',
 2071        'secret_store_id',
 2072        'tags',
 2073        'tls_required',
 2074        'username',
 2075    ]
 2076
 2077    def __init__(
 2078        self,
 2079        bind_interface=None,
 2080        egress_filter=None,
 2081        healthy=None,
 2082        hostname=None,
 2083        id=None,
 2084        name=None,
 2085        password=None,
 2086        port=None,
 2087        port_override=None,
 2088        secret_store_id=None,
 2089        tags=None,
 2090        tls_required=None,
 2091        username=None,
 2092    ):
 2093        self.bind_interface = bind_interface if bind_interface is not None else ''
 2094        '''
 2095         Bind interface
 2096        '''
 2097        self.egress_filter = egress_filter if egress_filter is not None else ''
 2098        '''
 2099         A filter applied to the routing logic to pin datasource to nodes.
 2100        '''
 2101        self.healthy = healthy if healthy is not None else False
 2102        '''
 2103         True if the datasource is reachable and the credentials are valid.
 2104        '''
 2105        self.hostname = hostname if hostname is not None else ''
 2106        '''
 2107
 2108        '''
 2109        self.id = id if id is not None else ''
 2110        '''
 2111         Unique identifier of the Resource.
 2112        '''
 2113        self.name = name if name is not None else ''
 2114        '''
 2115         Unique human-readable name of the Resource.
 2116        '''
 2117        self.password = password if password is not None else ''
 2118        '''
 2119
 2120        '''
 2121        self.port = port if port is not None else 0
 2122        '''
 2123
 2124        '''
 2125        self.port_override = port_override if port_override is not None else 0
 2126        '''
 2127
 2128        '''
 2129        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 2130        '''
 2131         ID of the secret store containing credentials for this resource, if any.
 2132        '''
 2133        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 2134        '''
 2135         Tags is a map of key, value pairs.
 2136        '''
 2137        self.tls_required = tls_required if tls_required is not None else False
 2138        '''
 2139
 2140        '''
 2141        self.username = username if username is not None else ''
 2142        '''
 2143
 2144        '''
 2145
 2146    def __repr__(self):
 2147        return '<sdm.AmazonMQAMQP091 ' + \
 2148            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 2149            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 2150            'healthy: ' + repr(self.healthy) + ' ' +\
 2151            'hostname: ' + repr(self.hostname) + ' ' +\
 2152            'id: ' + repr(self.id) + ' ' +\
 2153            'name: ' + repr(self.name) + ' ' +\
 2154            'password: ' + repr(self.password) + ' ' +\
 2155            'port: ' + repr(self.port) + ' ' +\
 2156            'port_override: ' + repr(self.port_override) + ' ' +\
 2157            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 2158            'tags: ' + repr(self.tags) + ' ' +\
 2159            'tls_required: ' + repr(self.tls_required) + ' ' +\
 2160            'username: ' + repr(self.username) + ' ' +\
 2161            '>'
 2162
 2163    def to_dict(self):
 2164        return {
 2165            'bind_interface': self.bind_interface,
 2166            'egress_filter': self.egress_filter,
 2167            'healthy': self.healthy,
 2168            'hostname': self.hostname,
 2169            'id': self.id,
 2170            'name': self.name,
 2171            'password': self.password,
 2172            'port': self.port,
 2173            'port_override': self.port_override,
 2174            'secret_store_id': self.secret_store_id,
 2175            'tags': self.tags,
 2176            'tls_required': self.tls_required,
 2177            'username': self.username,
 2178        }
 2179
 2180    @classmethod
 2181    def from_dict(cls, d):
 2182        return cls(
 2183            bind_interface=d.get('bind_interface'),
 2184            egress_filter=d.get('egress_filter'),
 2185            healthy=d.get('healthy'),
 2186            hostname=d.get('hostname'),
 2187            id=d.get('id'),
 2188            name=d.get('name'),
 2189            password=d.get('password'),
 2190            port=d.get('port'),
 2191            port_override=d.get('port_override'),
 2192            secret_store_id=d.get('secret_store_id'),
 2193            tags=d.get('tags'),
 2194            tls_required=d.get('tls_required'),
 2195            username=d.get('username'),
 2196        )
 2197
 2198
 2199class Athena:
 2200    '''
 2201
 2202    '''
 2203    __slots__ = [
 2204        'access_key',
 2205        'bind_interface',
 2206        'egress_filter',
 2207        'healthy',
 2208        'id',
 2209        'name',
 2210        'output',
 2211        'port_override',
 2212        'region',
 2213        'role_arn',
 2214        'role_external_id',
 2215        'secret_access_key',
 2216        'secret_store_id',
 2217        'tags',
 2218    ]
 2219
 2220    def __init__(
 2221        self,
 2222        access_key=None,
 2223        bind_interface=None,
 2224        egress_filter=None,
 2225        healthy=None,
 2226        id=None,
 2227        name=None,
 2228        output=None,
 2229        port_override=None,
 2230        region=None,
 2231        role_arn=None,
 2232        role_external_id=None,
 2233        secret_access_key=None,
 2234        secret_store_id=None,
 2235        tags=None,
 2236    ):
 2237        self.access_key = access_key if access_key is not None else ''
 2238        '''
 2239
 2240        '''
 2241        self.bind_interface = bind_interface if bind_interface is not None else ''
 2242        '''
 2243         Bind interface
 2244        '''
 2245        self.egress_filter = egress_filter if egress_filter is not None else ''
 2246        '''
 2247         A filter applied to the routing logic to pin datasource to nodes.
 2248        '''
 2249        self.healthy = healthy if healthy is not None else False
 2250        '''
 2251         True if the datasource is reachable and the credentials are valid.
 2252        '''
 2253        self.id = id if id is not None else ''
 2254        '''
 2255         Unique identifier of the Resource.
 2256        '''
 2257        self.name = name if name is not None else ''
 2258        '''
 2259         Unique human-readable name of the Resource.
 2260        '''
 2261        self.output = output if output is not None else ''
 2262        '''
 2263
 2264        '''
 2265        self.port_override = port_override if port_override is not None else 0
 2266        '''
 2267
 2268        '''
 2269        self.region = region if region is not None else ''
 2270        '''
 2271
 2272        '''
 2273        self.role_arn = role_arn if role_arn is not None else ''
 2274        '''
 2275
 2276        '''
 2277        self.role_external_id = role_external_id if role_external_id is not None else ''
 2278        '''
 2279
 2280        '''
 2281        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
 2282        '''
 2283
 2284        '''
 2285        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 2286        '''
 2287         ID of the secret store containing credentials for this resource, if any.
 2288        '''
 2289        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 2290        '''
 2291         Tags is a map of key, value pairs.
 2292        '''
 2293
 2294    def __repr__(self):
 2295        return '<sdm.Athena ' + \
 2296            'access_key: ' + repr(self.access_key) + ' ' +\
 2297            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 2298            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 2299            'healthy: ' + repr(self.healthy) + ' ' +\
 2300            'id: ' + repr(self.id) + ' ' +\
 2301            'name: ' + repr(self.name) + ' ' +\
 2302            'output: ' + repr(self.output) + ' ' +\
 2303            'port_override: ' + repr(self.port_override) + ' ' +\
 2304            'region: ' + repr(self.region) + ' ' +\
 2305            'role_arn: ' + repr(self.role_arn) + ' ' +\
 2306            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
 2307            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
 2308            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 2309            'tags: ' + repr(self.tags) + ' ' +\
 2310            '>'
 2311
 2312    def to_dict(self):
 2313        return {
 2314            'access_key': self.access_key,
 2315            'bind_interface': self.bind_interface,
 2316            'egress_filter': self.egress_filter,
 2317            'healthy': self.healthy,
 2318            'id': self.id,
 2319            'name': self.name,
 2320            'output': self.output,
 2321            'port_override': self.port_override,
 2322            'region': self.region,
 2323            'role_arn': self.role_arn,
 2324            'role_external_id': self.role_external_id,
 2325            'secret_access_key': self.secret_access_key,
 2326            'secret_store_id': self.secret_store_id,
 2327            'tags': self.tags,
 2328        }
 2329
 2330    @classmethod
 2331    def from_dict(cls, d):
 2332        return cls(
 2333            access_key=d.get('access_key'),
 2334            bind_interface=d.get('bind_interface'),
 2335            egress_filter=d.get('egress_filter'),
 2336            healthy=d.get('healthy'),
 2337            id=d.get('id'),
 2338            name=d.get('name'),
 2339            output=d.get('output'),
 2340            port_override=d.get('port_override'),
 2341            region=d.get('region'),
 2342            role_arn=d.get('role_arn'),
 2343            role_external_id=d.get('role_external_id'),
 2344            secret_access_key=d.get('secret_access_key'),
 2345            secret_store_id=d.get('secret_store_id'),
 2346            tags=d.get('tags'),
 2347        )
 2348
 2349
 2350class AuroraMysql:
 2351    '''
 2352
 2353    '''
 2354    __slots__ = [
 2355        'bind_interface',
 2356        'database',
 2357        'egress_filter',
 2358        'healthy',
 2359        'hostname',
 2360        'id',
 2361        'name',
 2362        'password',
 2363        'port',
 2364        'port_override',
 2365        'secret_store_id',
 2366        'tags',
 2367        'username',
 2368    ]
 2369
 2370    def __init__(
 2371        self,
 2372        bind_interface=None,
 2373        database=None,
 2374        egress_filter=None,
 2375        healthy=None,
 2376        hostname=None,
 2377        id=None,
 2378        name=None,
 2379        password=None,
 2380        port=None,
 2381        port_override=None,
 2382        secret_store_id=None,
 2383        tags=None,
 2384        username=None,
 2385    ):
 2386        self.bind_interface = bind_interface if bind_interface is not None else ''
 2387        '''
 2388         Bind interface
 2389        '''
 2390        self.database = database if database is not None else ''
 2391        '''
 2392
 2393        '''
 2394        self.egress_filter = egress_filter if egress_filter is not None else ''
 2395        '''
 2396         A filter applied to the routing logic to pin datasource to nodes.
 2397        '''
 2398        self.healthy = healthy if healthy is not None else False
 2399        '''
 2400         True if the datasource is reachable and the credentials are valid.
 2401        '''
 2402        self.hostname = hostname if hostname is not None else ''
 2403        '''
 2404
 2405        '''
 2406        self.id = id if id is not None else ''
 2407        '''
 2408         Unique identifier of the Resource.
 2409        '''
 2410        self.name = name if name is not None else ''
 2411        '''
 2412         Unique human-readable name of the Resource.
 2413        '''
 2414        self.password = password if password is not None else ''
 2415        '''
 2416
 2417        '''
 2418        self.port = port if port is not None else 0
 2419        '''
 2420
 2421        '''
 2422        self.port_override = port_override if port_override is not None else 0
 2423        '''
 2424
 2425        '''
 2426        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 2427        '''
 2428         ID of the secret store containing credentials for this resource, if any.
 2429        '''
 2430        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 2431        '''
 2432         Tags is a map of key, value pairs.
 2433        '''
 2434        self.username = username if username is not None else ''
 2435        '''
 2436
 2437        '''
 2438
 2439    def __repr__(self):
 2440        return '<sdm.AuroraMysql ' + \
 2441            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 2442            'database: ' + repr(self.database) + ' ' +\
 2443            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 2444            'healthy: ' + repr(self.healthy) + ' ' +\
 2445            'hostname: ' + repr(self.hostname) + ' ' +\
 2446            'id: ' + repr(self.id) + ' ' +\
 2447            'name: ' + repr(self.name) + ' ' +\
 2448            'password: ' + repr(self.password) + ' ' +\
 2449            'port: ' + repr(self.port) + ' ' +\
 2450            'port_override: ' + repr(self.port_override) + ' ' +\
 2451            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 2452            'tags: ' + repr(self.tags) + ' ' +\
 2453            'username: ' + repr(self.username) + ' ' +\
 2454            '>'
 2455
 2456    def to_dict(self):
 2457        return {
 2458            'bind_interface': self.bind_interface,
 2459            'database': self.database,
 2460            'egress_filter': self.egress_filter,
 2461            'healthy': self.healthy,
 2462            'hostname': self.hostname,
 2463            'id': self.id,
 2464            'name': self.name,
 2465            'password': self.password,
 2466            'port': self.port,
 2467            'port_override': self.port_override,
 2468            'secret_store_id': self.secret_store_id,
 2469            'tags': self.tags,
 2470            'username': self.username,
 2471        }
 2472
 2473    @classmethod
 2474    def from_dict(cls, d):
 2475        return cls(
 2476            bind_interface=d.get('bind_interface'),
 2477            database=d.get('database'),
 2478            egress_filter=d.get('egress_filter'),
 2479            healthy=d.get('healthy'),
 2480            hostname=d.get('hostname'),
 2481            id=d.get('id'),
 2482            name=d.get('name'),
 2483            password=d.get('password'),
 2484            port=d.get('port'),
 2485            port_override=d.get('port_override'),
 2486            secret_store_id=d.get('secret_store_id'),
 2487            tags=d.get('tags'),
 2488            username=d.get('username'),
 2489        )
 2490
 2491
 2492class AuroraPostgres:
 2493    '''
 2494
 2495    '''
 2496    __slots__ = [
 2497        'bind_interface',
 2498        'database',
 2499        'egress_filter',
 2500        'healthy',
 2501        'hostname',
 2502        'id',
 2503        'name',
 2504        'override_database',
 2505        'password',
 2506        'port',
 2507        'port_override',
 2508        'secret_store_id',
 2509        'tags',
 2510        'username',
 2511    ]
 2512
 2513    def __init__(
 2514        self,
 2515        bind_interface=None,
 2516        database=None,
 2517        egress_filter=None,
 2518        healthy=None,
 2519        hostname=None,
 2520        id=None,
 2521        name=None,
 2522        override_database=None,
 2523        password=None,
 2524        port=None,
 2525        port_override=None,
 2526        secret_store_id=None,
 2527        tags=None,
 2528        username=None,
 2529    ):
 2530        self.bind_interface = bind_interface if bind_interface is not None else ''
 2531        '''
 2532         Bind interface
 2533        '''
 2534        self.database = database if database is not None else ''
 2535        '''
 2536
 2537        '''
 2538        self.egress_filter = egress_filter if egress_filter is not None else ''
 2539        '''
 2540         A filter applied to the routing logic to pin datasource to nodes.
 2541        '''
 2542        self.healthy = healthy if healthy is not None else False
 2543        '''
 2544         True if the datasource is reachable and the credentials are valid.
 2545        '''
 2546        self.hostname = hostname if hostname is not None else ''
 2547        '''
 2548
 2549        '''
 2550        self.id = id if id is not None else ''
 2551        '''
 2552         Unique identifier of the Resource.
 2553        '''
 2554        self.name = name if name is not None else ''
 2555        '''
 2556         Unique human-readable name of the Resource.
 2557        '''
 2558        self.override_database = override_database if override_database is not None else False
 2559        '''
 2560
 2561        '''
 2562        self.password = password if password is not None else ''
 2563        '''
 2564
 2565        '''
 2566        self.port = port if port is not None else 0
 2567        '''
 2568
 2569        '''
 2570        self.port_override = port_override if port_override is not None else 0
 2571        '''
 2572
 2573        '''
 2574        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 2575        '''
 2576         ID of the secret store containing credentials for this resource, if any.
 2577        '''
 2578        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 2579        '''
 2580         Tags is a map of key, value pairs.
 2581        '''
 2582        self.username = username if username is not None else ''
 2583        '''
 2584
 2585        '''
 2586
 2587    def __repr__(self):
 2588        return '<sdm.AuroraPostgres ' + \
 2589            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 2590            'database: ' + repr(self.database) + ' ' +\
 2591            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 2592            'healthy: ' + repr(self.healthy) + ' ' +\
 2593            'hostname: ' + repr(self.hostname) + ' ' +\
 2594            'id: ' + repr(self.id) + ' ' +\
 2595            'name: ' + repr(self.name) + ' ' +\
 2596            'override_database: ' + repr(self.override_database) + ' ' +\
 2597            'password: ' + repr(self.password) + ' ' +\
 2598            'port: ' + repr(self.port) + ' ' +\
 2599            'port_override: ' + repr(self.port_override) + ' ' +\
 2600            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 2601            'tags: ' + repr(self.tags) + ' ' +\
 2602            'username: ' + repr(self.username) + ' ' +\
 2603            '>'
 2604
 2605    def to_dict(self):
 2606        return {
 2607            'bind_interface': self.bind_interface,
 2608            'database': self.database,
 2609            'egress_filter': self.egress_filter,
 2610            'healthy': self.healthy,
 2611            'hostname': self.hostname,
 2612            'id': self.id,
 2613            'name': self.name,
 2614            'override_database': self.override_database,
 2615            'password': self.password,
 2616            'port': self.port,
 2617            'port_override': self.port_override,
 2618            'secret_store_id': self.secret_store_id,
 2619            'tags': self.tags,
 2620            'username': self.username,
 2621        }
 2622
 2623    @classmethod
 2624    def from_dict(cls, d):
 2625        return cls(
 2626            bind_interface=d.get('bind_interface'),
 2627            database=d.get('database'),
 2628            egress_filter=d.get('egress_filter'),
 2629            healthy=d.get('healthy'),
 2630            hostname=d.get('hostname'),
 2631            id=d.get('id'),
 2632            name=d.get('name'),
 2633            override_database=d.get('override_database'),
 2634            password=d.get('password'),
 2635            port=d.get('port'),
 2636            port_override=d.get('port_override'),
 2637            secret_store_id=d.get('secret_store_id'),
 2638            tags=d.get('tags'),
 2639            username=d.get('username'),
 2640        )
 2641
 2642
 2643class Azure:
 2644    '''
 2645
 2646    '''
 2647    __slots__ = [
 2648        'app_id',
 2649        'bind_interface',
 2650        'egress_filter',
 2651        'healthy',
 2652        'id',
 2653        'name',
 2654        'password',
 2655        'secret_store_id',
 2656        'tags',
 2657        'tenant_id',
 2658    ]
 2659
 2660    def __init__(
 2661        self,
 2662        app_id=None,
 2663        bind_interface=None,
 2664        egress_filter=None,
 2665        healthy=None,
 2666        id=None,
 2667        name=None,
 2668        password=None,
 2669        secret_store_id=None,
 2670        tags=None,
 2671        tenant_id=None,
 2672    ):
 2673        self.app_id = app_id if app_id is not None else ''
 2674        '''
 2675
 2676        '''
 2677        self.bind_interface = bind_interface if bind_interface is not None else ''
 2678        '''
 2679         Bind interface
 2680        '''
 2681        self.egress_filter = egress_filter if egress_filter is not None else ''
 2682        '''
 2683         A filter applied to the routing logic to pin datasource to nodes.
 2684        '''
 2685        self.healthy = healthy if healthy is not None else False
 2686        '''
 2687         True if the datasource is reachable and the credentials are valid.
 2688        '''
 2689        self.id = id if id is not None else ''
 2690        '''
 2691         Unique identifier of the Resource.
 2692        '''
 2693        self.name = name if name is not None else ''
 2694        '''
 2695         Unique human-readable name of the Resource.
 2696        '''
 2697        self.password = password if password is not None else ''
 2698        '''
 2699
 2700        '''
 2701        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 2702        '''
 2703         ID of the secret store containing credentials for this resource, if any.
 2704        '''
 2705        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 2706        '''
 2707         Tags is a map of key, value pairs.
 2708        '''
 2709        self.tenant_id = tenant_id if tenant_id is not None else ''
 2710        '''
 2711
 2712        '''
 2713
 2714    def __repr__(self):
 2715        return '<sdm.Azure ' + \
 2716            'app_id: ' + repr(self.app_id) + ' ' +\
 2717            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 2718            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 2719            'healthy: ' + repr(self.healthy) + ' ' +\
 2720            'id: ' + repr(self.id) + ' ' +\
 2721            'name: ' + repr(self.name) + ' ' +\
 2722            'password: ' + repr(self.password) + ' ' +\
 2723            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 2724            'tags: ' + repr(self.tags) + ' ' +\
 2725            'tenant_id: ' + repr(self.tenant_id) + ' ' +\
 2726            '>'
 2727
 2728    def to_dict(self):
 2729        return {
 2730            'app_id': self.app_id,
 2731            'bind_interface': self.bind_interface,
 2732            'egress_filter': self.egress_filter,
 2733            'healthy': self.healthy,
 2734            'id': self.id,
 2735            'name': self.name,
 2736            'password': self.password,
 2737            'secret_store_id': self.secret_store_id,
 2738            'tags': self.tags,
 2739            'tenant_id': self.tenant_id,
 2740        }
 2741
 2742    @classmethod
 2743    def from_dict(cls, d):
 2744        return cls(
 2745            app_id=d.get('app_id'),
 2746            bind_interface=d.get('bind_interface'),
 2747            egress_filter=d.get('egress_filter'),
 2748            healthy=d.get('healthy'),
 2749            id=d.get('id'),
 2750            name=d.get('name'),
 2751            password=d.get('password'),
 2752            secret_store_id=d.get('secret_store_id'),
 2753            tags=d.get('tags'),
 2754            tenant_id=d.get('tenant_id'),
 2755        )
 2756
 2757
 2758class AzureCertificate:
 2759    '''
 2760
 2761    '''
 2762    __slots__ = [
 2763        'app_id',
 2764        'bind_interface',
 2765        'client_certificate',
 2766        'egress_filter',
 2767        'healthy',
 2768        'id',
 2769        'name',
 2770        'secret_store_id',
 2771        'tags',
 2772        'tenant_id',
 2773    ]
 2774
 2775    def __init__(
 2776        self,
 2777        app_id=None,
 2778        bind_interface=None,
 2779        client_certificate=None,
 2780        egress_filter=None,
 2781        healthy=None,
 2782        id=None,
 2783        name=None,
 2784        secret_store_id=None,
 2785        tags=None,
 2786        tenant_id=None,
 2787    ):
 2788        self.app_id = app_id if app_id is not None else ''
 2789        '''
 2790
 2791        '''
 2792        self.bind_interface = bind_interface if bind_interface is not None else ''
 2793        '''
 2794         Bind interface
 2795        '''
 2796        self.client_certificate = client_certificate if client_certificate is not None else ''
 2797        '''
 2798
 2799        '''
 2800        self.egress_filter = egress_filter if egress_filter is not None else ''
 2801        '''
 2802         A filter applied to the routing logic to pin datasource to nodes.
 2803        '''
 2804        self.healthy = healthy if healthy is not None else False
 2805        '''
 2806         True if the datasource is reachable and the credentials are valid.
 2807        '''
 2808        self.id = id if id is not None else ''
 2809        '''
 2810         Unique identifier of the Resource.
 2811        '''
 2812        self.name = name if name is not None else ''
 2813        '''
 2814         Unique human-readable name of the Resource.
 2815        '''
 2816        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 2817        '''
 2818         ID of the secret store containing credentials for this resource, if any.
 2819        '''
 2820        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 2821        '''
 2822         Tags is a map of key, value pairs.
 2823        '''
 2824        self.tenant_id = tenant_id if tenant_id is not None else ''
 2825        '''
 2826
 2827        '''
 2828
 2829    def __repr__(self):
 2830        return '<sdm.AzureCertificate ' + \
 2831            'app_id: ' + repr(self.app_id) + ' ' +\
 2832            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 2833            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
 2834            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 2835            'healthy: ' + repr(self.healthy) + ' ' +\
 2836            'id: ' + repr(self.id) + ' ' +\
 2837            'name: ' + repr(self.name) + ' ' +\
 2838            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 2839            'tags: ' + repr(self.tags) + ' ' +\
 2840            'tenant_id: ' + repr(self.tenant_id) + ' ' +\
 2841            '>'
 2842
 2843    def to_dict(self):
 2844        return {
 2845            'app_id': self.app_id,
 2846            'bind_interface': self.bind_interface,
 2847            'client_certificate': self.client_certificate,
 2848            'egress_filter': self.egress_filter,
 2849            'healthy': self.healthy,
 2850            'id': self.id,
 2851            'name': self.name,
 2852            'secret_store_id': self.secret_store_id,
 2853            'tags': self.tags,
 2854            'tenant_id': self.tenant_id,
 2855        }
 2856
 2857    @classmethod
 2858    def from_dict(cls, d):
 2859        return cls(
 2860            app_id=d.get('app_id'),
 2861            bind_interface=d.get('bind_interface'),
 2862            client_certificate=d.get('client_certificate'),
 2863            egress_filter=d.get('egress_filter'),
 2864            healthy=d.get('healthy'),
 2865            id=d.get('id'),
 2866            name=d.get('name'),
 2867            secret_store_id=d.get('secret_store_id'),
 2868            tags=d.get('tags'),
 2869            tenant_id=d.get('tenant_id'),
 2870        )
 2871
 2872
 2873class AzurePostgres:
 2874    '''
 2875
 2876    '''
 2877    __slots__ = [
 2878        'bind_interface',
 2879        'database',
 2880        'egress_filter',
 2881        'healthy',
 2882        'hostname',
 2883        'id',
 2884        'name',
 2885        'override_database',
 2886        'password',
 2887        'port',
 2888        'port_override',
 2889        'secret_store_id',
 2890        'tags',
 2891        'username',
 2892    ]
 2893
 2894    def __init__(
 2895        self,
 2896        bind_interface=None,
 2897        database=None,
 2898        egress_filter=None,
 2899        healthy=None,
 2900        hostname=None,
 2901        id=None,
 2902        name=None,
 2903        override_database=None,
 2904        password=None,
 2905        port=None,
 2906        port_override=None,
 2907        secret_store_id=None,
 2908        tags=None,
 2909        username=None,
 2910    ):
 2911        self.bind_interface = bind_interface if bind_interface is not None else ''
 2912        '''
 2913         Bind interface
 2914        '''
 2915        self.database = database if database is not None else ''
 2916        '''
 2917
 2918        '''
 2919        self.egress_filter = egress_filter if egress_filter is not None else ''
 2920        '''
 2921         A filter applied to the routing logic to pin datasource to nodes.
 2922        '''
 2923        self.healthy = healthy if healthy is not None else False
 2924        '''
 2925         True if the datasource is reachable and the credentials are valid.
 2926        '''
 2927        self.hostname = hostname if hostname is not None else ''
 2928        '''
 2929
 2930        '''
 2931        self.id = id if id is not None else ''
 2932        '''
 2933         Unique identifier of the Resource.
 2934        '''
 2935        self.name = name if name is not None else ''
 2936        '''
 2937         Unique human-readable name of the Resource.
 2938        '''
 2939        self.override_database = override_database if override_database is not None else False
 2940        '''
 2941
 2942        '''
 2943        self.password = password if password is not None else ''
 2944        '''
 2945
 2946        '''
 2947        self.port = port if port is not None else 0
 2948        '''
 2949
 2950        '''
 2951        self.port_override = port_override if port_override is not None else 0
 2952        '''
 2953
 2954        '''
 2955        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 2956        '''
 2957         ID of the secret store containing credentials for this resource, if any.
 2958        '''
 2959        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 2960        '''
 2961         Tags is a map of key, value pairs.
 2962        '''
 2963        self.username = username if username is not None else ''
 2964        '''
 2965
 2966        '''
 2967
 2968    def __repr__(self):
 2969        return '<sdm.AzurePostgres ' + \
 2970            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 2971            'database: ' + repr(self.database) + ' ' +\
 2972            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 2973            'healthy: ' + repr(self.healthy) + ' ' +\
 2974            'hostname: ' + repr(self.hostname) + ' ' +\
 2975            'id: ' + repr(self.id) + ' ' +\
 2976            'name: ' + repr(self.name) + ' ' +\
 2977            'override_database: ' + repr(self.override_database) + ' ' +\
 2978            'password: ' + repr(self.password) + ' ' +\
 2979            'port: ' + repr(self.port) + ' ' +\
 2980            'port_override: ' + repr(self.port_override) + ' ' +\
 2981            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 2982            'tags: ' + repr(self.tags) + ' ' +\
 2983            'username: ' + repr(self.username) + ' ' +\
 2984            '>'
 2985
 2986    def to_dict(self):
 2987        return {
 2988            'bind_interface': self.bind_interface,
 2989            'database': self.database,
 2990            'egress_filter': self.egress_filter,
 2991            'healthy': self.healthy,
 2992            'hostname': self.hostname,
 2993            'id': self.id,
 2994            'name': self.name,
 2995            'override_database': self.override_database,
 2996            'password': self.password,
 2997            'port': self.port,
 2998            'port_override': self.port_override,
 2999            'secret_store_id': self.secret_store_id,
 3000            'tags': self.tags,
 3001            'username': self.username,
 3002        }
 3003
 3004    @classmethod
 3005    def from_dict(cls, d):
 3006        return cls(
 3007            bind_interface=d.get('bind_interface'),
 3008            database=d.get('database'),
 3009            egress_filter=d.get('egress_filter'),
 3010            healthy=d.get('healthy'),
 3011            hostname=d.get('hostname'),
 3012            id=d.get('id'),
 3013            name=d.get('name'),
 3014            override_database=d.get('override_database'),
 3015            password=d.get('password'),
 3016            port=d.get('port'),
 3017            port_override=d.get('port_override'),
 3018            secret_store_id=d.get('secret_store_id'),
 3019            tags=d.get('tags'),
 3020            username=d.get('username'),
 3021        )
 3022
 3023
 3024class AzureStore:
 3025    '''
 3026
 3027    '''
 3028    __slots__ = [
 3029        'id',
 3030        'name',
 3031        'tags',
 3032        'vault_uri',
 3033    ]
 3034
 3035    def __init__(
 3036        self,
 3037        id=None,
 3038        name=None,
 3039        tags=None,
 3040        vault_uri=None,
 3041    ):
 3042        self.id = id if id is not None else ''
 3043        '''
 3044         Unique identifier of the SecretStore.
 3045        '''
 3046        self.name = name if name is not None else ''
 3047        '''
 3048         Unique human-readable name of the SecretStore.
 3049        '''
 3050        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 3051        '''
 3052         Tags is a map of key, value pairs.
 3053        '''
 3054        self.vault_uri = vault_uri if vault_uri is not None else ''
 3055        '''
 3056
 3057        '''
 3058
 3059    def __repr__(self):
 3060        return '<sdm.AzureStore ' + \
 3061            'id: ' + repr(self.id) + ' ' +\
 3062            'name: ' + repr(self.name) + ' ' +\
 3063            'tags: ' + repr(self.tags) + ' ' +\
 3064            'vault_uri: ' + repr(self.vault_uri) + ' ' +\
 3065            '>'
 3066
 3067    def to_dict(self):
 3068        return {
 3069            'id': self.id,
 3070            'name': self.name,
 3071            'tags': self.tags,
 3072            'vault_uri': self.vault_uri,
 3073        }
 3074
 3075    @classmethod
 3076    def from_dict(cls, d):
 3077        return cls(
 3078            id=d.get('id'),
 3079            name=d.get('name'),
 3080            tags=d.get('tags'),
 3081            vault_uri=d.get('vault_uri'),
 3082        )
 3083
 3084
 3085class BigQuery:
 3086    '''
 3087
 3088    '''
 3089    __slots__ = [
 3090        'bind_interface',
 3091        'egress_filter',
 3092        'endpoint',
 3093        'healthy',
 3094        'id',
 3095        'name',
 3096        'port_override',
 3097        'private_key',
 3098        'project',
 3099        'secret_store_id',
 3100        'tags',
 3101        'username',
 3102    ]
 3103
 3104    def __init__(
 3105        self,
 3106        bind_interface=None,
 3107        egress_filter=None,
 3108        endpoint=None,
 3109        healthy=None,
 3110        id=None,
 3111        name=None,
 3112        port_override=None,
 3113        private_key=None,
 3114        project=None,
 3115        secret_store_id=None,
 3116        tags=None,
 3117        username=None,
 3118    ):
 3119        self.bind_interface = bind_interface if bind_interface is not None else ''
 3120        '''
 3121         Bind interface
 3122        '''
 3123        self.egress_filter = egress_filter if egress_filter is not None else ''
 3124        '''
 3125         A filter applied to the routing logic to pin datasource to nodes.
 3126        '''
 3127        self.endpoint = endpoint if endpoint is not None else ''
 3128        '''
 3129
 3130        '''
 3131        self.healthy = healthy if healthy is not None else False
 3132        '''
 3133         True if the datasource is reachable and the credentials are valid.
 3134        '''
 3135        self.id = id if id is not None else ''
 3136        '''
 3137         Unique identifier of the Resource.
 3138        '''
 3139        self.name = name if name is not None else ''
 3140        '''
 3141         Unique human-readable name of the Resource.
 3142        '''
 3143        self.port_override = port_override if port_override is not None else 0
 3144        '''
 3145
 3146        '''
 3147        self.private_key = private_key if private_key is not None else ''
 3148        '''
 3149
 3150        '''
 3151        self.project = project if project is not None else ''
 3152        '''
 3153
 3154        '''
 3155        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 3156        '''
 3157         ID of the secret store containing credentials for this resource, if any.
 3158        '''
 3159        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 3160        '''
 3161         Tags is a map of key, value pairs.
 3162        '''
 3163        self.username = username if username is not None else ''
 3164        '''
 3165
 3166        '''
 3167
 3168    def __repr__(self):
 3169        return '<sdm.BigQuery ' + \
 3170            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 3171            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 3172            'endpoint: ' + repr(self.endpoint) + ' ' +\
 3173            'healthy: ' + repr(self.healthy) + ' ' +\
 3174            'id: ' + repr(self.id) + ' ' +\
 3175            'name: ' + repr(self.name) + ' ' +\
 3176            'port_override: ' + repr(self.port_override) + ' ' +\
 3177            'private_key: ' + repr(self.private_key) + ' ' +\
 3178            'project: ' + repr(self.project) + ' ' +\
 3179            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 3180            'tags: ' + repr(self.tags) + ' ' +\
 3181            'username: ' + repr(self.username) + ' ' +\
 3182            '>'
 3183
 3184    def to_dict(self):
 3185        return {
 3186            'bind_interface': self.bind_interface,
 3187            'egress_filter': self.egress_filter,
 3188            'endpoint': self.endpoint,
 3189            'healthy': self.healthy,
 3190            'id': self.id,
 3191            'name': self.name,
 3192            'port_override': self.port_override,
 3193            'private_key': self.private_key,
 3194            'project': self.project,
 3195            'secret_store_id': self.secret_store_id,
 3196            'tags': self.tags,
 3197            'username': self.username,
 3198        }
 3199
 3200    @classmethod
 3201    def from_dict(cls, d):
 3202        return cls(
 3203            bind_interface=d.get('bind_interface'),
 3204            egress_filter=d.get('egress_filter'),
 3205            endpoint=d.get('endpoint'),
 3206            healthy=d.get('healthy'),
 3207            id=d.get('id'),
 3208            name=d.get('name'),
 3209            port_override=d.get('port_override'),
 3210            private_key=d.get('private_key'),
 3211            project=d.get('project'),
 3212            secret_store_id=d.get('secret_store_id'),
 3213            tags=d.get('tags'),
 3214            username=d.get('username'),
 3215        )
 3216
 3217
 3218class Cassandra:
 3219    '''
 3220
 3221    '''
 3222    __slots__ = [
 3223        'bind_interface',
 3224        'egress_filter',
 3225        'healthy',
 3226        'hostname',
 3227        'id',
 3228        'name',
 3229        'password',
 3230        'port',
 3231        'port_override',
 3232        'secret_store_id',
 3233        'tags',
 3234        'tls_required',
 3235        'username',
 3236    ]
 3237
 3238    def __init__(
 3239        self,
 3240        bind_interface=None,
 3241        egress_filter=None,
 3242        healthy=None,
 3243        hostname=None,
 3244        id=None,
 3245        name=None,
 3246        password=None,
 3247        port=None,
 3248        port_override=None,
 3249        secret_store_id=None,
 3250        tags=None,
 3251        tls_required=None,
 3252        username=None,
 3253    ):
 3254        self.bind_interface = bind_interface if bind_interface is not None else ''
 3255        '''
 3256         Bind interface
 3257        '''
 3258        self.egress_filter = egress_filter if egress_filter is not None else ''
 3259        '''
 3260         A filter applied to the routing logic to pin datasource to nodes.
 3261        '''
 3262        self.healthy = healthy if healthy is not None else False
 3263        '''
 3264         True if the datasource is reachable and the credentials are valid.
 3265        '''
 3266        self.hostname = hostname if hostname is not None else ''
 3267        '''
 3268
 3269        '''
 3270        self.id = id if id is not None else ''
 3271        '''
 3272         Unique identifier of the Resource.
 3273        '''
 3274        self.name = name if name is not None else ''
 3275        '''
 3276         Unique human-readable name of the Resource.
 3277        '''
 3278        self.password = password if password is not None else ''
 3279        '''
 3280
 3281        '''
 3282        self.port = port if port is not None else 0
 3283        '''
 3284
 3285        '''
 3286        self.port_override = port_override if port_override is not None else 0
 3287        '''
 3288
 3289        '''
 3290        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 3291        '''
 3292         ID of the secret store containing credentials for this resource, if any.
 3293        '''
 3294        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 3295        '''
 3296         Tags is a map of key, value pairs.
 3297        '''
 3298        self.tls_required = tls_required if tls_required is not None else False
 3299        '''
 3300
 3301        '''
 3302        self.username = username if username is not None else ''
 3303        '''
 3304
 3305        '''
 3306
 3307    def __repr__(self):
 3308        return '<sdm.Cassandra ' + \
 3309            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 3310            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 3311            'healthy: ' + repr(self.healthy) + ' ' +\
 3312            'hostname: ' + repr(self.hostname) + ' ' +\
 3313            'id: ' + repr(self.id) + ' ' +\
 3314            'name: ' + repr(self.name) + ' ' +\
 3315            'password: ' + repr(self.password) + ' ' +\
 3316            'port: ' + repr(self.port) + ' ' +\
 3317            'port_override: ' + repr(self.port_override) + ' ' +\
 3318            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 3319            'tags: ' + repr(self.tags) + ' ' +\
 3320            'tls_required: ' + repr(self.tls_required) + ' ' +\
 3321            'username: ' + repr(self.username) + ' ' +\
 3322            '>'
 3323
 3324    def to_dict(self):
 3325        return {
 3326            'bind_interface': self.bind_interface,
 3327            'egress_filter': self.egress_filter,
 3328            'healthy': self.healthy,
 3329            'hostname': self.hostname,
 3330            'id': self.id,
 3331            'name': self.name,
 3332            'password': self.password,
 3333            'port': self.port,
 3334            'port_override': self.port_override,
 3335            'secret_store_id': self.secret_store_id,
 3336            'tags': self.tags,
 3337            'tls_required': self.tls_required,
 3338            'username': self.username,
 3339        }
 3340
 3341    @classmethod
 3342    def from_dict(cls, d):
 3343        return cls(
 3344            bind_interface=d.get('bind_interface'),
 3345            egress_filter=d.get('egress_filter'),
 3346            healthy=d.get('healthy'),
 3347            hostname=d.get('hostname'),
 3348            id=d.get('id'),
 3349            name=d.get('name'),
 3350            password=d.get('password'),
 3351            port=d.get('port'),
 3352            port_override=d.get('port_override'),
 3353            secret_store_id=d.get('secret_store_id'),
 3354            tags=d.get('tags'),
 3355            tls_required=d.get('tls_required'),
 3356            username=d.get('username'),
 3357        )
 3358
 3359
 3360class Citus:
 3361    '''
 3362
 3363    '''
 3364    __slots__ = [
 3365        'bind_interface',
 3366        'database',
 3367        'egress_filter',
 3368        'healthy',
 3369        'hostname',
 3370        'id',
 3371        'name',
 3372        'override_database',
 3373        'password',
 3374        'port',
 3375        'port_override',
 3376        'secret_store_id',
 3377        'tags',
 3378        'username',
 3379    ]
 3380
 3381    def __init__(
 3382        self,
 3383        bind_interface=None,
 3384        database=None,
 3385        egress_filter=None,
 3386        healthy=None,
 3387        hostname=None,
 3388        id=None,
 3389        name=None,
 3390        override_database=None,
 3391        password=None,
 3392        port=None,
 3393        port_override=None,
 3394        secret_store_id=None,
 3395        tags=None,
 3396        username=None,
 3397    ):
 3398        self.bind_interface = bind_interface if bind_interface is not None else ''
 3399        '''
 3400         Bind interface
 3401        '''
 3402        self.database = database if database is not None else ''
 3403        '''
 3404
 3405        '''
 3406        self.egress_filter = egress_filter if egress_filter is not None else ''
 3407        '''
 3408         A filter applied to the routing logic to pin datasource to nodes.
 3409        '''
 3410        self.healthy = healthy if healthy is not None else False
 3411        '''
 3412         True if the datasource is reachable and the credentials are valid.
 3413        '''
 3414        self.hostname = hostname if hostname is not None else ''
 3415        '''
 3416
 3417        '''
 3418        self.id = id if id is not None else ''
 3419        '''
 3420         Unique identifier of the Resource.
 3421        '''
 3422        self.name = name if name is not None else ''
 3423        '''
 3424         Unique human-readable name of the Resource.
 3425        '''
 3426        self.override_database = override_database if override_database is not None else False
 3427        '''
 3428
 3429        '''
 3430        self.password = password if password is not None else ''
 3431        '''
 3432
 3433        '''
 3434        self.port = port if port is not None else 0
 3435        '''
 3436
 3437        '''
 3438        self.port_override = port_override if port_override is not None else 0
 3439        '''
 3440
 3441        '''
 3442        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 3443        '''
 3444         ID of the secret store containing credentials for this resource, if any.
 3445        '''
 3446        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 3447        '''
 3448         Tags is a map of key, value pairs.
 3449        '''
 3450        self.username = username if username is not None else ''
 3451        '''
 3452
 3453        '''
 3454
 3455    def __repr__(self):
 3456        return '<sdm.Citus ' + \
 3457            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 3458            'database: ' + repr(self.database) + ' ' +\
 3459            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 3460            'healthy: ' + repr(self.healthy) + ' ' +\
 3461            'hostname: ' + repr(self.hostname) + ' ' +\
 3462            'id: ' + repr(self.id) + ' ' +\
 3463            'name: ' + repr(self.name) + ' ' +\
 3464            'override_database: ' + repr(self.override_database) + ' ' +\
 3465            'password: ' + repr(self.password) + ' ' +\
 3466            'port: ' + repr(self.port) + ' ' +\
 3467            'port_override: ' + repr(self.port_override) + ' ' +\
 3468            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 3469            'tags: ' + repr(self.tags) + ' ' +\
 3470            'username: ' + repr(self.username) + ' ' +\
 3471            '>'
 3472
 3473    def to_dict(self):
 3474        return {
 3475            'bind_interface': self.bind_interface,
 3476            'database': self.database,
 3477            'egress_filter': self.egress_filter,
 3478            'healthy': self.healthy,
 3479            'hostname': self.hostname,
 3480            'id': self.id,
 3481            'name': self.name,
 3482            'override_database': self.override_database,
 3483            'password': self.password,
 3484            'port': self.port,
 3485            'port_override': self.port_override,
 3486            'secret_store_id': self.secret_store_id,
 3487            'tags': self.tags,
 3488            'username': self.username,
 3489        }
 3490
 3491    @classmethod
 3492    def from_dict(cls, d):
 3493        return cls(
 3494            bind_interface=d.get('bind_interface'),
 3495            database=d.get('database'),
 3496            egress_filter=d.get('egress_filter'),
 3497            healthy=d.get('healthy'),
 3498            hostname=d.get('hostname'),
 3499            id=d.get('id'),
 3500            name=d.get('name'),
 3501            override_database=d.get('override_database'),
 3502            password=d.get('password'),
 3503            port=d.get('port'),
 3504            port_override=d.get('port_override'),
 3505            secret_store_id=d.get('secret_store_id'),
 3506            tags=d.get('tags'),
 3507            username=d.get('username'),
 3508        )
 3509
 3510
 3511class Clustrix:
 3512    '''
 3513
 3514    '''
 3515    __slots__ = [
 3516        'bind_interface',
 3517        'database',
 3518        'egress_filter',
 3519        'healthy',
 3520        'hostname',
 3521        'id',
 3522        'name',
 3523        'password',
 3524        'port',
 3525        'port_override',
 3526        'secret_store_id',
 3527        'tags',
 3528        'username',
 3529    ]
 3530
 3531    def __init__(
 3532        self,
 3533        bind_interface=None,
 3534        database=None,
 3535        egress_filter=None,
 3536        healthy=None,
 3537        hostname=None,
 3538        id=None,
 3539        name=None,
 3540        password=None,
 3541        port=None,
 3542        port_override=None,
 3543        secret_store_id=None,
 3544        tags=None,
 3545        username=None,
 3546    ):
 3547        self.bind_interface = bind_interface if bind_interface is not None else ''
 3548        '''
 3549         Bind interface
 3550        '''
 3551        self.database = database if database is not None else ''
 3552        '''
 3553
 3554        '''
 3555        self.egress_filter = egress_filter if egress_filter is not None else ''
 3556        '''
 3557         A filter applied to the routing logic to pin datasource to nodes.
 3558        '''
 3559        self.healthy = healthy if healthy is not None else False
 3560        '''
 3561         True if the datasource is reachable and the credentials are valid.
 3562        '''
 3563        self.hostname = hostname if hostname is not None else ''
 3564        '''
 3565
 3566        '''
 3567        self.id = id if id is not None else ''
 3568        '''
 3569         Unique identifier of the Resource.
 3570        '''
 3571        self.name = name if name is not None else ''
 3572        '''
 3573         Unique human-readable name of the Resource.
 3574        '''
 3575        self.password = password if password is not None else ''
 3576        '''
 3577
 3578        '''
 3579        self.port = port if port is not None else 0
 3580        '''
 3581
 3582        '''
 3583        self.port_override = port_override if port_override is not None else 0
 3584        '''
 3585
 3586        '''
 3587        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 3588        '''
 3589         ID of the secret store containing credentials for this resource, if any.
 3590        '''
 3591        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 3592        '''
 3593         Tags is a map of key, value pairs.
 3594        '''
 3595        self.username = username if username is not None else ''
 3596        '''
 3597
 3598        '''
 3599
 3600    def __repr__(self):
 3601        return '<sdm.Clustrix ' + \
 3602            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 3603            'database: ' + repr(self.database) + ' ' +\
 3604            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 3605            'healthy: ' + repr(self.healthy) + ' ' +\
 3606            'hostname: ' + repr(self.hostname) + ' ' +\
 3607            'id: ' + repr(self.id) + ' ' +\
 3608            'name: ' + repr(self.name) + ' ' +\
 3609            'password: ' + repr(self.password) + ' ' +\
 3610            'port: ' + repr(self.port) + ' ' +\
 3611            'port_override: ' + repr(self.port_override) + ' ' +\
 3612            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 3613            'tags: ' + repr(self.tags) + ' ' +\
 3614            'username: ' + repr(self.username) + ' ' +\
 3615            '>'
 3616
 3617    def to_dict(self):
 3618        return {
 3619            'bind_interface': self.bind_interface,
 3620            'database': self.database,
 3621            'egress_filter': self.egress_filter,
 3622            'healthy': self.healthy,
 3623            'hostname': self.hostname,
 3624            'id': self.id,
 3625            'name': self.name,
 3626            'password': self.password,
 3627            'port': self.port,
 3628            'port_override': self.port_override,
 3629            'secret_store_id': self.secret_store_id,
 3630            'tags': self.tags,
 3631            'username': self.username,
 3632        }
 3633
 3634    @classmethod
 3635    def from_dict(cls, d):
 3636        return cls(
 3637            bind_interface=d.get('bind_interface'),
 3638            database=d.get('database'),
 3639            egress_filter=d.get('egress_filter'),
 3640            healthy=d.get('healthy'),
 3641            hostname=d.get('hostname'),
 3642            id=d.get('id'),
 3643            name=d.get('name'),
 3644            password=d.get('password'),
 3645            port=d.get('port'),
 3646            port_override=d.get('port_override'),
 3647            secret_store_id=d.get('secret_store_id'),
 3648            tags=d.get('tags'),
 3649            username=d.get('username'),
 3650        )
 3651
 3652
 3653class Cockroach:
 3654    '''
 3655
 3656    '''
 3657    __slots__ = [
 3658        'bind_interface',
 3659        'database',
 3660        'egress_filter',
 3661        'healthy',
 3662        'hostname',
 3663        'id',
 3664        'name',
 3665        'override_database',
 3666        'password',
 3667        'port',
 3668        'port_override',
 3669        'secret_store_id',
 3670        'tags',
 3671        'username',
 3672    ]
 3673
 3674    def __init__(
 3675        self,
 3676        bind_interface=None,
 3677        database=None,
 3678        egress_filter=None,
 3679        healthy=None,
 3680        hostname=None,
 3681        id=None,
 3682        name=None,
 3683        override_database=None,
 3684        password=None,
 3685        port=None,
 3686        port_override=None,
 3687        secret_store_id=None,
 3688        tags=None,
 3689        username=None,
 3690    ):
 3691        self.bind_interface = bind_interface if bind_interface is not None else ''
 3692        '''
 3693         Bind interface
 3694        '''
 3695        self.database = database if database is not None else ''
 3696        '''
 3697
 3698        '''
 3699        self.egress_filter = egress_filter if egress_filter is not None else ''
 3700        '''
 3701         A filter applied to the routing logic to pin datasource to nodes.
 3702        '''
 3703        self.healthy = healthy if healthy is not None else False
 3704        '''
 3705         True if the datasource is reachable and the credentials are valid.
 3706        '''
 3707        self.hostname = hostname if hostname is not None else ''
 3708        '''
 3709
 3710        '''
 3711        self.id = id if id is not None else ''
 3712        '''
 3713         Unique identifier of the Resource.
 3714        '''
 3715        self.name = name if name is not None else ''
 3716        '''
 3717         Unique human-readable name of the Resource.
 3718        '''
 3719        self.override_database = override_database if override_database is not None else False
 3720        '''
 3721
 3722        '''
 3723        self.password = password if password is not None else ''
 3724        '''
 3725
 3726        '''
 3727        self.port = port if port is not None else 0
 3728        '''
 3729
 3730        '''
 3731        self.port_override = port_override if port_override is not None else 0
 3732        '''
 3733
 3734        '''
 3735        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 3736        '''
 3737         ID of the secret store containing credentials for this resource, if any.
 3738        '''
 3739        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 3740        '''
 3741         Tags is a map of key, value pairs.
 3742        '''
 3743        self.username = username if username is not None else ''
 3744        '''
 3745
 3746        '''
 3747
 3748    def __repr__(self):
 3749        return '<sdm.Cockroach ' + \
 3750            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 3751            'database: ' + repr(self.database) + ' ' +\
 3752            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 3753            'healthy: ' + repr(self.healthy) + ' ' +\
 3754            'hostname: ' + repr(self.hostname) + ' ' +\
 3755            'id: ' + repr(self.id) + ' ' +\
 3756            'name: ' + repr(self.name) + ' ' +\
 3757            'override_database: ' + repr(self.override_database) + ' ' +\
 3758            'password: ' + repr(self.password) + ' ' +\
 3759            'port: ' + repr(self.port) + ' ' +\
 3760            'port_override: ' + repr(self.port_override) + ' ' +\
 3761            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 3762            'tags: ' + repr(self.tags) + ' ' +\
 3763            'username: ' + repr(self.username) + ' ' +\
 3764            '>'
 3765
 3766    def to_dict(self):
 3767        return {
 3768            'bind_interface': self.bind_interface,
 3769            'database': self.database,
 3770            'egress_filter': self.egress_filter,
 3771            'healthy': self.healthy,
 3772            'hostname': self.hostname,
 3773            'id': self.id,
 3774            'name': self.name,
 3775            'override_database': self.override_database,
 3776            'password': self.password,
 3777            'port': self.port,
 3778            'port_override': self.port_override,
 3779            'secret_store_id': self.secret_store_id,
 3780            'tags': self.tags,
 3781            'username': self.username,
 3782        }
 3783
 3784    @classmethod
 3785    def from_dict(cls, d):
 3786        return cls(
 3787            bind_interface=d.get('bind_interface'),
 3788            database=d.get('database'),
 3789            egress_filter=d.get('egress_filter'),
 3790            healthy=d.get('healthy'),
 3791            hostname=d.get('hostname'),
 3792            id=d.get('id'),
 3793            name=d.get('name'),
 3794            override_database=d.get('override_database'),
 3795            password=d.get('password'),
 3796            port=d.get('port'),
 3797            port_override=d.get('port_override'),
 3798            secret_store_id=d.get('secret_store_id'),
 3799            tags=d.get('tags'),
 3800            username=d.get('username'),
 3801        )
 3802
 3803
 3804class ControlPanelGetSSHCAPublicKeyResponse:
 3805    '''
 3806     ControlPanelGetSSHCAPublicKeyResponse represents a request for an
 3807     organization's SSH Certificate Authority public key.
 3808    '''
 3809    __slots__ = [
 3810        'meta',
 3811        'public_key',
 3812        'rate_limit',
 3813    ]
 3814
 3815    def __init__(
 3816        self,
 3817        meta=None,
 3818        public_key=None,
 3819        rate_limit=None,
 3820    ):
 3821        self.meta = meta if meta is not None else None
 3822        '''
 3823         Reserved for future use.
 3824        '''
 3825        self.public_key = public_key if public_key is not None else ''
 3826        '''
 3827         The public key of the SSH Certificate Authority, in OpenSSH RSA public
 3828         key format.
 3829        '''
 3830        self.rate_limit = rate_limit if rate_limit is not None else None
 3831        '''
 3832         Rate limit information.
 3833        '''
 3834
 3835    def __repr__(self):
 3836        return '<sdm.ControlPanelGetSSHCAPublicKeyResponse ' + \
 3837            'meta: ' + repr(self.meta) + ' ' +\
 3838            'public_key: ' + repr(self.public_key) + ' ' +\
 3839            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 3840            '>'
 3841
 3842    def to_dict(self):
 3843        return {
 3844            'meta': self.meta,
 3845            'public_key': self.public_key,
 3846            'rate_limit': self.rate_limit,
 3847        }
 3848
 3849    @classmethod
 3850    def from_dict(cls, d):
 3851        return cls(
 3852            meta=d.get('meta'),
 3853            public_key=d.get('public_key'),
 3854            rate_limit=d.get('rate_limit'),
 3855        )
 3856
 3857
 3858class ControlPanelVerifyJWTResponse:
 3859    '''
 3860     ControlPanelVerifyJWTResponse reports whether x-sdm-token is valid.
 3861    '''
 3862    __slots__ = [
 3863        'meta',
 3864        'rate_limit',
 3865        'valid',
 3866    ]
 3867
 3868    def __init__(
 3869        self,
 3870        meta=None,
 3871        rate_limit=None,
 3872        valid=None,
 3873    ):
 3874        self.meta = meta if meta is not None else None
 3875        '''
 3876         Reserved for future use.
 3877        '''
 3878        self.rate_limit = rate_limit if rate_limit is not None else None
 3879        '''
 3880         Rate limit information.
 3881        '''
 3882        self.valid = valid if valid is not None else False
 3883        '''
 3884         Reports if the given token is valid.
 3885        '''
 3886
 3887    def __repr__(self):
 3888        return '<sdm.ControlPanelVerifyJWTResponse ' + \
 3889            'meta: ' + repr(self.meta) + ' ' +\
 3890            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 3891            'valid: ' + repr(self.valid) + ' ' +\
 3892            '>'
 3893
 3894    def to_dict(self):
 3895        return {
 3896            'meta': self.meta,
 3897            'rate_limit': self.rate_limit,
 3898            'valid': self.valid,
 3899        }
 3900
 3901    @classmethod
 3902    def from_dict(cls, d):
 3903        return cls(
 3904            meta=d.get('meta'),
 3905            rate_limit=d.get('rate_limit'),
 3906            valid=d.get('valid'),
 3907        )
 3908
 3909
 3910class CreateResponseMetadata:
 3911    '''
 3912     CreateResponseMetadata is reserved for future use.
 3913    '''
 3914    __slots__ = []
 3915
 3916    def __init__(self, ):
 3917        pass
 3918
 3919    def __repr__(self):
 3920        return '<sdm.CreateResponseMetadata ' + \
 3921            '>'
 3922
 3923    def to_dict(self):
 3924        return {}
 3925
 3926    @classmethod
 3927    def from_dict(cls, d):
 3928        return cls()
 3929
 3930
 3931class DB2I:
 3932    '''
 3933
 3934    '''
 3935    __slots__ = [
 3936        'bind_interface',
 3937        'egress_filter',
 3938        'healthy',
 3939        'hostname',
 3940        'id',
 3941        'name',
 3942        'password',
 3943        'port',
 3944        'port_override',
 3945        'secret_store_id',
 3946        'tags',
 3947        'tls_required',
 3948        'username',
 3949    ]
 3950
 3951    def __init__(
 3952        self,
 3953        bind_interface=None,
 3954        egress_filter=None,
 3955        healthy=None,
 3956        hostname=None,
 3957        id=None,
 3958        name=None,
 3959        password=None,
 3960        port=None,
 3961        port_override=None,
 3962        secret_store_id=None,
 3963        tags=None,
 3964        tls_required=None,
 3965        username=None,
 3966    ):
 3967        self.bind_interface = bind_interface if bind_interface is not None else ''
 3968        '''
 3969         Bind interface
 3970        '''
 3971        self.egress_filter = egress_filter if egress_filter is not None else ''
 3972        '''
 3973         A filter applied to the routing logic to pin datasource to nodes.
 3974        '''
 3975        self.healthy = healthy if healthy is not None else False
 3976        '''
 3977         True if the datasource is reachable and the credentials are valid.
 3978        '''
 3979        self.hostname = hostname if hostname is not None else ''
 3980        '''
 3981
 3982        '''
 3983        self.id = id if id is not None else ''
 3984        '''
 3985         Unique identifier of the Resource.
 3986        '''
 3987        self.name = name if name is not None else ''
 3988        '''
 3989         Unique human-readable name of the Resource.
 3990        '''
 3991        self.password = password if password is not None else ''
 3992        '''
 3993
 3994        '''
 3995        self.port = port if port is not None else 0
 3996        '''
 3997
 3998        '''
 3999        self.port_override = port_override if port_override is not None else 0
 4000        '''
 4001
 4002        '''
 4003        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 4004        '''
 4005         ID of the secret store containing credentials for this resource, if any.
 4006        '''
 4007        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 4008        '''
 4009         Tags is a map of key, value pairs.
 4010        '''
 4011        self.tls_required = tls_required if tls_required is not None else False
 4012        '''
 4013
 4014        '''
 4015        self.username = username if username is not None else ''
 4016        '''
 4017
 4018        '''
 4019
 4020    def __repr__(self):
 4021        return '<sdm.DB2I ' + \
 4022            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 4023            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 4024            'healthy: ' + repr(self.healthy) + ' ' +\
 4025            'hostname: ' + repr(self.hostname) + ' ' +\
 4026            'id: ' + repr(self.id) + ' ' +\
 4027            'name: ' + repr(self.name) + ' ' +\
 4028            'password: ' + repr(self.password) + ' ' +\
 4029            'port: ' + repr(self.port) + ' ' +\
 4030            'port_override: ' + repr(self.port_override) + ' ' +\
 4031            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 4032            'tags: ' + repr(self.tags) + ' ' +\
 4033            'tls_required: ' + repr(self.tls_required) + ' ' +\
 4034            'username: ' + repr(self.username) + ' ' +\
 4035            '>'
 4036
 4037    def to_dict(self):
 4038        return {
 4039            'bind_interface': self.bind_interface,
 4040            'egress_filter': self.egress_filter,
 4041            'healthy': self.healthy,
 4042            'hostname': self.hostname,
 4043            'id': self.id,
 4044            'name': self.name,
 4045            'password': self.password,
 4046            'port': self.port,
 4047            'port_override': self.port_override,
 4048            'secret_store_id': self.secret_store_id,
 4049            'tags': self.tags,
 4050            'tls_required': self.tls_required,
 4051            'username': self.username,
 4052        }
 4053
 4054    @classmethod
 4055    def from_dict(cls, d):
 4056        return cls(
 4057            bind_interface=d.get('bind_interface'),
 4058            egress_filter=d.get('egress_filter'),
 4059            healthy=d.get('healthy'),
 4060            hostname=d.get('hostname'),
 4061            id=d.get('id'),
 4062            name=d.get('name'),
 4063            password=d.get('password'),
 4064            port=d.get('port'),
 4065            port_override=d.get('port_override'),
 4066            secret_store_id=d.get('secret_store_id'),
 4067            tags=d.get('tags'),
 4068            tls_required=d.get('tls_required'),
 4069            username=d.get('username'),
 4070        )
 4071
 4072
 4073class DB2LUW:
 4074    '''
 4075
 4076    '''
 4077    __slots__ = [
 4078        'bind_interface',
 4079        'database',
 4080        'egress_filter',
 4081        'healthy',
 4082        'hostname',
 4083        'id',
 4084        'name',
 4085        'password',
 4086        'port',
 4087        'port_override',
 4088        'secret_store_id',
 4089        'tags',
 4090        'username',
 4091    ]
 4092
 4093    def __init__(
 4094        self,
 4095        bind_interface=None,
 4096        database=None,
 4097        egress_filter=None,
 4098        healthy=None,
 4099        hostname=None,
 4100        id=None,
 4101        name=None,
 4102        password=None,
 4103        port=None,
 4104        port_override=None,
 4105        secret_store_id=None,
 4106        tags=None,
 4107        username=None,
 4108    ):
 4109        self.bind_interface = bind_interface if bind_interface is not None else ''
 4110        '''
 4111         Bind interface
 4112        '''
 4113        self.database = database if database is not None else ''
 4114        '''
 4115
 4116        '''
 4117        self.egress_filter = egress_filter if egress_filter is not None else ''
 4118        '''
 4119         A filter applied to the routing logic to pin datasource to nodes.
 4120        '''
 4121        self.healthy = healthy if healthy is not None else False
 4122        '''
 4123         True if the datasource is reachable and the credentials are valid.
 4124        '''
 4125        self.hostname = hostname if hostname is not None else ''
 4126        '''
 4127
 4128        '''
 4129        self.id = id if id is not None else ''
 4130        '''
 4131         Unique identifier of the Resource.
 4132        '''
 4133        self.name = name if name is not None else ''
 4134        '''
 4135         Unique human-readable name of the Resource.
 4136        '''
 4137        self.password = password if password is not None else ''
 4138        '''
 4139
 4140        '''
 4141        self.port = port if port is not None else 0
 4142        '''
 4143
 4144        '''
 4145        self.port_override = port_override if port_override is not None else 0
 4146        '''
 4147
 4148        '''
 4149        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 4150        '''
 4151         ID of the secret store containing credentials for this resource, if any.
 4152        '''
 4153        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 4154        '''
 4155         Tags is a map of key, value pairs.
 4156        '''
 4157        self.username = username if username is not None else ''
 4158        '''
 4159
 4160        '''
 4161
 4162    def __repr__(self):
 4163        return '<sdm.DB2LUW ' + \
 4164            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 4165            'database: ' + repr(self.database) + ' ' +\
 4166            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 4167            'healthy: ' + repr(self.healthy) + ' ' +\
 4168            'hostname: ' + repr(self.hostname) + ' ' +\
 4169            'id: ' + repr(self.id) + ' ' +\
 4170            'name: ' + repr(self.name) + ' ' +\
 4171            'password: ' + repr(self.password) + ' ' +\
 4172            'port: ' + repr(self.port) + ' ' +\
 4173            'port_override: ' + repr(self.port_override) + ' ' +\
 4174            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 4175            'tags: ' + repr(self.tags) + ' ' +\
 4176            'username: ' + repr(self.username) + ' ' +\
 4177            '>'
 4178
 4179    def to_dict(self):
 4180        return {
 4181            'bind_interface': self.bind_interface,
 4182            'database': self.database,
 4183            'egress_filter': self.egress_filter,
 4184            'healthy': self.healthy,
 4185            'hostname': self.hostname,
 4186            'id': self.id,
 4187            'name': self.name,
 4188            'password': self.password,
 4189            'port': self.port,
 4190            'port_override': self.port_override,
 4191            'secret_store_id': self.secret_store_id,
 4192            'tags': self.tags,
 4193            'username': self.username,
 4194        }
 4195
 4196    @classmethod
 4197    def from_dict(cls, d):
 4198        return cls(
 4199            bind_interface=d.get('bind_interface'),
 4200            database=d.get('database'),
 4201            egress_filter=d.get('egress_filter'),
 4202            healthy=d.get('healthy'),
 4203            hostname=d.get('hostname'),
 4204            id=d.get('id'),
 4205            name=d.get('name'),
 4206            password=d.get('password'),
 4207            port=d.get('port'),
 4208            port_override=d.get('port_override'),
 4209            secret_store_id=d.get('secret_store_id'),
 4210            tags=d.get('tags'),
 4211            username=d.get('username'),
 4212        )
 4213
 4214
 4215class DeleteResponseMetadata:
 4216    '''
 4217     DeleteResponseMetadata is reserved for future use.
 4218    '''
 4219    __slots__ = []
 4220
 4221    def __init__(self, ):
 4222        pass
 4223
 4224    def __repr__(self):
 4225        return '<sdm.DeleteResponseMetadata ' + \
 4226            '>'
 4227
 4228    def to_dict(self):
 4229        return {}
 4230
 4231    @classmethod
 4232    def from_dict(cls, d):
 4233        return cls()
 4234
 4235
 4236class DocumentDBHost:
 4237    '''
 4238
 4239    '''
 4240    __slots__ = [
 4241        'auth_database',
 4242        'bind_interface',
 4243        'egress_filter',
 4244        'healthy',
 4245        'hostname',
 4246        'id',
 4247        'name',
 4248        'password',
 4249        'port',
 4250        'port_override',
 4251        'secret_store_id',
 4252        'tags',
 4253        'username',
 4254    ]
 4255
 4256    def __init__(
 4257        self,
 4258        auth_database=None,
 4259        bind_interface=None,
 4260        egress_filter=None,
 4261        healthy=None,
 4262        hostname=None,
 4263        id=None,
 4264        name=None,
 4265        password=None,
 4266        port=None,
 4267        port_override=None,
 4268        secret_store_id=None,
 4269        tags=None,
 4270        username=None,
 4271    ):
 4272        self.auth_database = auth_database if auth_database is not None else ''
 4273        '''
 4274
 4275        '''
 4276        self.bind_interface = bind_interface if bind_interface is not None else ''
 4277        '''
 4278         Bind interface
 4279        '''
 4280        self.egress_filter = egress_filter if egress_filter is not None else ''
 4281        '''
 4282         A filter applied to the routing logic to pin datasource to nodes.
 4283        '''
 4284        self.healthy = healthy if healthy is not None else False
 4285        '''
 4286         True if the datasource is reachable and the credentials are valid.
 4287        '''
 4288        self.hostname = hostname if hostname is not None else ''
 4289        '''
 4290
 4291        '''
 4292        self.id = id if id is not None else ''
 4293        '''
 4294         Unique identifier of the Resource.
 4295        '''
 4296        self.name = name if name is not None else ''
 4297        '''
 4298         Unique human-readable name of the Resource.
 4299        '''
 4300        self.password = password if password is not None else ''
 4301        '''
 4302
 4303        '''
 4304        self.port = port if port is not None else 0
 4305        '''
 4306
 4307        '''
 4308        self.port_override = port_override if port_override is not None else 0
 4309        '''
 4310
 4311        '''
 4312        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 4313        '''
 4314         ID of the secret store containing credentials for this resource, if any.
 4315        '''
 4316        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 4317        '''
 4318         Tags is a map of key, value pairs.
 4319        '''
 4320        self.username = username if username is not None else ''
 4321        '''
 4322
 4323        '''
 4324
 4325    def __repr__(self):
 4326        return '<sdm.DocumentDBHost ' + \
 4327            'auth_database: ' + repr(self.auth_database) + ' ' +\
 4328            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 4329            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 4330            'healthy: ' + repr(self.healthy) + ' ' +\
 4331            'hostname: ' + repr(self.hostname) + ' ' +\
 4332            'id: ' + repr(self.id) + ' ' +\
 4333            'name: ' + repr(self.name) + ' ' +\
 4334            'password: ' + repr(self.password) + ' ' +\
 4335            'port: ' + repr(self.port) + ' ' +\
 4336            'port_override: ' + repr(self.port_override) + ' ' +\
 4337            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 4338            'tags: ' + repr(self.tags) + ' ' +\
 4339            'username: ' + repr(self.username) + ' ' +\
 4340            '>'
 4341
 4342    def to_dict(self):
 4343        return {
 4344            'auth_database': self.auth_database,
 4345            'bind_interface': self.bind_interface,
 4346            'egress_filter': self.egress_filter,
 4347            'healthy': self.healthy,
 4348            'hostname': self.hostname,
 4349            'id': self.id,
 4350            'name': self.name,
 4351            'password': self.password,
 4352            'port': self.port,
 4353            'port_override': self.port_override,
 4354            'secret_store_id': self.secret_store_id,
 4355            'tags': self.tags,
 4356            'username': self.username,
 4357        }
 4358
 4359    @classmethod
 4360    def from_dict(cls, d):
 4361        return cls(
 4362            auth_database=d.get('auth_database'),
 4363            bind_interface=d.get('bind_interface'),
 4364            egress_filter=d.get('egress_filter'),
 4365            healthy=d.get('healthy'),
 4366            hostname=d.get('hostname'),
 4367            id=d.get('id'),
 4368            name=d.get('name'),
 4369            password=d.get('password'),
 4370            port=d.get('port'),
 4371            port_override=d.get('port_override'),
 4372            secret_store_id=d.get('secret_store_id'),
 4373            tags=d.get('tags'),
 4374            username=d.get('username'),
 4375        )
 4376
 4377
 4378class DocumentDBReplicaSet:
 4379    '''
 4380
 4381    '''
 4382    __slots__ = [
 4383        'auth_database',
 4384        'bind_interface',
 4385        'connect_to_replica',
 4386        'egress_filter',
 4387        'healthy',
 4388        'hostname',
 4389        'id',
 4390        'name',
 4391        'password',
 4392        'port_override',
 4393        'replica_set',
 4394        'secret_store_id',
 4395        'tags',
 4396        'username',
 4397    ]
 4398
 4399    def __init__(
 4400        self,
 4401        auth_database=None,
 4402        bind_interface=None,
 4403        connect_to_replica=None,
 4404        egress_filter=None,
 4405        healthy=None,
 4406        hostname=None,
 4407        id=None,
 4408        name=None,
 4409        password=None,
 4410        port_override=None,
 4411        replica_set=None,
 4412        secret_store_id=None,
 4413        tags=None,
 4414        username=None,
 4415    ):
 4416        self.auth_database = auth_database if auth_database is not None else ''
 4417        '''
 4418
 4419        '''
 4420        self.bind_interface = bind_interface if bind_interface is not None else ''
 4421        '''
 4422         Bind interface
 4423        '''
 4424        self.connect_to_replica = connect_to_replica if connect_to_replica is not None else False
 4425        '''
 4426
 4427        '''
 4428        self.egress_filter = egress_filter if egress_filter is not None else ''
 4429        '''
 4430         A filter applied to the routing logic to pin datasource to nodes.
 4431        '''
 4432        self.healthy = healthy if healthy is not None else False
 4433        '''
 4434         True if the datasource is reachable and the credentials are valid.
 4435        '''
 4436        self.hostname = hostname if hostname is not None else ''
 4437        '''
 4438         Hostname must contain the hostname/port pairs of all instances in the replica set separated by commas.
 4439        '''
 4440        self.id = id if id is not None else ''
 4441        '''
 4442         Unique identifier of the Resource.
 4443        '''
 4444        self.name = name if name is not None else ''
 4445        '''
 4446         Unique human-readable name of the Resource.
 4447        '''
 4448        self.password = password if password is not None else ''
 4449        '''
 4450
 4451        '''
 4452        self.port_override = port_override if port_override is not None else 0
 4453        '''
 4454
 4455        '''
 4456        self.replica_set = replica_set if replica_set is not None else ''
 4457        '''
 4458
 4459        '''
 4460        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 4461        '''
 4462         ID of the secret store containing credentials for this resource, if any.
 4463        '''
 4464        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 4465        '''
 4466         Tags is a map of key, value pairs.
 4467        '''
 4468        self.username = username if username is not None else ''
 4469        '''
 4470
 4471        '''
 4472
 4473    def __repr__(self):
 4474        return '<sdm.DocumentDBReplicaSet ' + \
 4475            'auth_database: ' + repr(self.auth_database) + ' ' +\
 4476            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 4477            'connect_to_replica: ' + repr(self.connect_to_replica) + ' ' +\
 4478            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 4479            'healthy: ' + repr(self.healthy) + ' ' +\
 4480            'hostname: ' + repr(self.hostname) + ' ' +\
 4481            'id: ' + repr(self.id) + ' ' +\
 4482            'name: ' + repr(self.name) + ' ' +\
 4483            'password: ' + repr(self.password) + ' ' +\
 4484            'port_override: ' + repr(self.port_override) + ' ' +\
 4485            'replica_set: ' + repr(self.replica_set) + ' ' +\
 4486            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 4487            'tags: ' + repr(self.tags) + ' ' +\
 4488            'username: ' + repr(self.username) + ' ' +\
 4489            '>'
 4490
 4491    def to_dict(self):
 4492        return {
 4493            'auth_database': self.auth_database,
 4494            'bind_interface': self.bind_interface,
 4495            'connect_to_replica': self.connect_to_replica,
 4496            'egress_filter': self.egress_filter,
 4497            'healthy': self.healthy,
 4498            'hostname': self.hostname,
 4499            'id': self.id,
 4500            'name': self.name,
 4501            'password': self.password,
 4502            'port_override': self.port_override,
 4503            'replica_set': self.replica_set,
 4504            'secret_store_id': self.secret_store_id,
 4505            'tags': self.tags,
 4506            'username': self.username,
 4507        }
 4508
 4509    @classmethod
 4510    def from_dict(cls, d):
 4511        return cls(
 4512            auth_database=d.get('auth_database'),
 4513            bind_interface=d.get('bind_interface'),
 4514            connect_to_replica=d.get('connect_to_replica'),
 4515            egress_filter=d.get('egress_filter'),
 4516            healthy=d.get('healthy'),
 4517            hostname=d.get('hostname'),
 4518            id=d.get('id'),
 4519            name=d.get('name'),
 4520            password=d.get('password'),
 4521            port_override=d.get('port_override'),
 4522            replica_set=d.get('replica_set'),
 4523            secret_store_id=d.get('secret_store_id'),
 4524            tags=d.get('tags'),
 4525            username=d.get('username'),
 4526        )
 4527
 4528
 4529class Druid:
 4530    '''
 4531
 4532    '''
 4533    __slots__ = [
 4534        'bind_interface',
 4535        'egress_filter',
 4536        'healthy',
 4537        'hostname',
 4538        'id',
 4539        'name',
 4540        'password',
 4541        'port',
 4542        'port_override',
 4543        'secret_store_id',
 4544        'tags',
 4545        'username',
 4546    ]
 4547
 4548    def __init__(
 4549        self,
 4550        bind_interface=None,
 4551        egress_filter=None,
 4552        healthy=None,
 4553        hostname=None,
 4554        id=None,
 4555        name=None,
 4556        password=None,
 4557        port=None,
 4558        port_override=None,
 4559        secret_store_id=None,
 4560        tags=None,
 4561        username=None,
 4562    ):
 4563        self.bind_interface = bind_interface if bind_interface is not None else ''
 4564        '''
 4565         Bind interface
 4566        '''
 4567        self.egress_filter = egress_filter if egress_filter is not None else ''
 4568        '''
 4569         A filter applied to the routing logic to pin datasource to nodes.
 4570        '''
 4571        self.healthy = healthy if healthy is not None else False
 4572        '''
 4573         True if the datasource is reachable and the credentials are valid.
 4574        '''
 4575        self.hostname = hostname if hostname is not None else ''
 4576        '''
 4577
 4578        '''
 4579        self.id = id if id is not None else ''
 4580        '''
 4581         Unique identifier of the Resource.
 4582        '''
 4583        self.name = name if name is not None else ''
 4584        '''
 4585         Unique human-readable name of the Resource.
 4586        '''
 4587        self.password = password if password is not None else ''
 4588        '''
 4589
 4590        '''
 4591        self.port = port if port is not None else 0
 4592        '''
 4593
 4594        '''
 4595        self.port_override = port_override if port_override is not None else 0
 4596        '''
 4597
 4598        '''
 4599        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 4600        '''
 4601         ID of the secret store containing credentials for this resource, if any.
 4602        '''
 4603        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 4604        '''
 4605         Tags is a map of key, value pairs.
 4606        '''
 4607        self.username = username if username is not None else ''
 4608        '''
 4609
 4610        '''
 4611
 4612    def __repr__(self):
 4613        return '<sdm.Druid ' + \
 4614            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 4615            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 4616            'healthy: ' + repr(self.healthy) + ' ' +\
 4617            'hostname: ' + repr(self.hostname) + ' ' +\
 4618            'id: ' + repr(self.id) + ' ' +\
 4619            'name: ' + repr(self.name) + ' ' +\
 4620            'password: ' + repr(self.password) + ' ' +\
 4621            'port: ' + repr(self.port) + ' ' +\
 4622            'port_override: ' + repr(self.port_override) + ' ' +\
 4623            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 4624            'tags: ' + repr(self.tags) + ' ' +\
 4625            'username: ' + repr(self.username) + ' ' +\
 4626            '>'
 4627
 4628    def to_dict(self):
 4629        return {
 4630            'bind_interface': self.bind_interface,
 4631            'egress_filter': self.egress_filter,
 4632            'healthy': self.healthy,
 4633            'hostname': self.hostname,
 4634            'id': self.id,
 4635            'name': self.name,
 4636            'password': self.password,
 4637            'port': self.port,
 4638            'port_override': self.port_override,
 4639            'secret_store_id': self.secret_store_id,
 4640            'tags': self.tags,
 4641            'username': self.username,
 4642        }
 4643
 4644    @classmethod
 4645    def from_dict(cls, d):
 4646        return cls(
 4647            bind_interface=d.get('bind_interface'),
 4648            egress_filter=d.get('egress_filter'),
 4649            healthy=d.get('healthy'),
 4650            hostname=d.get('hostname'),
 4651            id=d.get('id'),
 4652            name=d.get('name'),
 4653            password=d.get('password'),
 4654            port=d.get('port'),
 4655            port_override=d.get('port_override'),
 4656            secret_store_id=d.get('secret_store_id'),
 4657            tags=d.get('tags'),
 4658            username=d.get('username'),
 4659        )
 4660
 4661
 4662class DynamoDB:
 4663    '''
 4664
 4665    '''
 4666    __slots__ = [
 4667        'access_key',
 4668        'bind_interface',
 4669        'egress_filter',
 4670        'endpoint',
 4671        'healthy',
 4672        'id',
 4673        'name',
 4674        'port_override',
 4675        'region',
 4676        'role_arn',
 4677        'role_external_id',
 4678        'secret_access_key',
 4679        'secret_store_id',
 4680        'tags',
 4681    ]
 4682
 4683    def __init__(
 4684        self,
 4685        access_key=None,
 4686        bind_interface=None,
 4687        egress_filter=None,
 4688        endpoint=None,
 4689        healthy=None,
 4690        id=None,
 4691        name=None,
 4692        port_override=None,
 4693        region=None,
 4694        role_arn=None,
 4695        role_external_id=None,
 4696        secret_access_key=None,
 4697        secret_store_id=None,
 4698        tags=None,
 4699    ):
 4700        self.access_key = access_key if access_key is not None else ''
 4701        '''
 4702
 4703        '''
 4704        self.bind_interface = bind_interface if bind_interface is not None else ''
 4705        '''
 4706         Bind interface
 4707        '''
 4708        self.egress_filter = egress_filter if egress_filter is not None else ''
 4709        '''
 4710         A filter applied to the routing logic to pin datasource to nodes.
 4711        '''
 4712        self.endpoint = endpoint if endpoint is not None else ''
 4713        '''
 4714
 4715        '''
 4716        self.healthy = healthy if healthy is not None else False
 4717        '''
 4718         True if the datasource is reachable and the credentials are valid.
 4719        '''
 4720        self.id = id if id is not None else ''
 4721        '''
 4722         Unique identifier of the Resource.
 4723        '''
 4724        self.name = name if name is not None else ''
 4725        '''
 4726         Unique human-readable name of the Resource.
 4727        '''
 4728        self.port_override = port_override if port_override is not None else 0
 4729        '''
 4730
 4731        '''
 4732        self.region = region if region is not None else ''
 4733        '''
 4734
 4735        '''
 4736        self.role_arn = role_arn if role_arn is not None else ''
 4737        '''
 4738
 4739        '''
 4740        self.role_external_id = role_external_id if role_external_id is not None else ''
 4741        '''
 4742
 4743        '''
 4744        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
 4745        '''
 4746
 4747        '''
 4748        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 4749        '''
 4750         ID of the secret store containing credentials for this resource, if any.
 4751        '''
 4752        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 4753        '''
 4754         Tags is a map of key, value pairs.
 4755        '''
 4756
 4757    def __repr__(self):
 4758        return '<sdm.DynamoDB ' + \
 4759            'access_key: ' + repr(self.access_key) + ' ' +\
 4760            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 4761            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 4762            'endpoint: ' + repr(self.endpoint) + ' ' +\
 4763            'healthy: ' + repr(self.healthy) + ' ' +\
 4764            'id: ' + repr(self.id) + ' ' +\
 4765            'name: ' + repr(self.name) + ' ' +\
 4766            'port_override: ' + repr(self.port_override) + ' ' +\
 4767            'region: ' + repr(self.region) + ' ' +\
 4768            'role_arn: ' + repr(self.role_arn) + ' ' +\
 4769            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
 4770            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
 4771            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 4772            'tags: ' + repr(self.tags) + ' ' +\
 4773            '>'
 4774
 4775    def to_dict(self):
 4776        return {
 4777            'access_key': self.access_key,
 4778            'bind_interface': self.bind_interface,
 4779            'egress_filter': self.egress_filter,
 4780            'endpoint': self.endpoint,
 4781            'healthy': self.healthy,
 4782            'id': self.id,
 4783            'name': self.name,
 4784            'port_override': self.port_override,
 4785            'region': self.region,
 4786            'role_arn': self.role_arn,
 4787            'role_external_id': self.role_external_id,
 4788            'secret_access_key': self.secret_access_key,
 4789            'secret_store_id': self.secret_store_id,
 4790            'tags': self.tags,
 4791        }
 4792
 4793    @classmethod
 4794    def from_dict(cls, d):
 4795        return cls(
 4796            access_key=d.get('access_key'),
 4797            bind_interface=d.get('bind_interface'),
 4798            egress_filter=d.get('egress_filter'),
 4799            endpoint=d.get('endpoint'),
 4800            healthy=d.get('healthy'),
 4801            id=d.get('id'),
 4802            name=d.get('name'),
 4803            port_override=d.get('port_override'),
 4804            region=d.get('region'),
 4805            role_arn=d.get('role_arn'),
 4806            role_external_id=d.get('role_external_id'),
 4807            secret_access_key=d.get('secret_access_key'),
 4808            secret_store_id=d.get('secret_store_id'),
 4809            tags=d.get('tags'),
 4810        )
 4811
 4812
 4813class Elastic:
 4814    '''
 4815
 4816    '''
 4817    __slots__ = [
 4818        'bind_interface',
 4819        'egress_filter',
 4820        'healthy',
 4821        'hostname',
 4822        'id',
 4823        'name',
 4824        'password',
 4825        'port',
 4826        'port_override',
 4827        'secret_store_id',
 4828        'tags',
 4829        'tls_required',
 4830        'username',
 4831    ]
 4832
 4833    def __init__(
 4834        self,
 4835        bind_interface=None,
 4836        egress_filter=None,
 4837        healthy=None,
 4838        hostname=None,
 4839        id=None,
 4840        name=None,
 4841        password=None,
 4842        port=None,
 4843        port_override=None,
 4844        secret_store_id=None,
 4845        tags=None,
 4846        tls_required=None,
 4847        username=None,
 4848    ):
 4849        self.bind_interface = bind_interface if bind_interface is not None else ''
 4850        '''
 4851         Bind interface
 4852        '''
 4853        self.egress_filter = egress_filter if egress_filter is not None else ''
 4854        '''
 4855         A filter applied to the routing logic to pin datasource to nodes.
 4856        '''
 4857        self.healthy = healthy if healthy is not None else False
 4858        '''
 4859         True if the datasource is reachable and the credentials are valid.
 4860        '''
 4861        self.hostname = hostname if hostname is not None else ''
 4862        '''
 4863
 4864        '''
 4865        self.id = id if id is not None else ''
 4866        '''
 4867         Unique identifier of the Resource.
 4868        '''
 4869        self.name = name if name is not None else ''
 4870        '''
 4871         Unique human-readable name of the Resource.
 4872        '''
 4873        self.password = password if password is not None else ''
 4874        '''
 4875
 4876        '''
 4877        self.port = port if port is not None else 0
 4878        '''
 4879
 4880        '''
 4881        self.port_override = port_override if port_override is not None else 0
 4882        '''
 4883
 4884        '''
 4885        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 4886        '''
 4887         ID of the secret store containing credentials for this resource, if any.
 4888        '''
 4889        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 4890        '''
 4891         Tags is a map of key, value pairs.
 4892        '''
 4893        self.tls_required = tls_required if tls_required is not None else False
 4894        '''
 4895
 4896        '''
 4897        self.username = username if username is not None else ''
 4898        '''
 4899
 4900        '''
 4901
 4902    def __repr__(self):
 4903        return '<sdm.Elastic ' + \
 4904            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 4905            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 4906            'healthy: ' + repr(self.healthy) + ' ' +\
 4907            'hostname: ' + repr(self.hostname) + ' ' +\
 4908            'id: ' + repr(self.id) + ' ' +\
 4909            'name: ' + repr(self.name) + ' ' +\
 4910            'password: ' + repr(self.password) + ' ' +\
 4911            'port: ' + repr(self.port) + ' ' +\
 4912            'port_override: ' + repr(self.port_override) + ' ' +\
 4913            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 4914            'tags: ' + repr(self.tags) + ' ' +\
 4915            'tls_required: ' + repr(self.tls_required) + ' ' +\
 4916            'username: ' + repr(self.username) + ' ' +\
 4917            '>'
 4918
 4919    def to_dict(self):
 4920        return {
 4921            'bind_interface': self.bind_interface,
 4922            'egress_filter': self.egress_filter,
 4923            'healthy': self.healthy,
 4924            'hostname': self.hostname,
 4925            'id': self.id,
 4926            'name': self.name,
 4927            'password': self.password,
 4928            'port': self.port,
 4929            'port_override': self.port_override,
 4930            'secret_store_id': self.secret_store_id,
 4931            'tags': self.tags,
 4932            'tls_required': self.tls_required,
 4933            'username': self.username,
 4934        }
 4935
 4936    @classmethod
 4937    def from_dict(cls, d):
 4938        return cls(
 4939            bind_interface=d.get('bind_interface'),
 4940            egress_filter=d.get('egress_filter'),
 4941            healthy=d.get('healthy'),
 4942            hostname=d.get('hostname'),
 4943            id=d.get('id'),
 4944            name=d.get('name'),
 4945            password=d.get('password'),
 4946            port=d.get('port'),
 4947            port_override=d.get('port_override'),
 4948            secret_store_id=d.get('secret_store_id'),
 4949            tags=d.get('tags'),
 4950            tls_required=d.get('tls_required'),
 4951            username=d.get('username'),
 4952        )
 4953
 4954
 4955class ElasticacheRedis:
 4956    '''
 4957
 4958    '''
 4959    __slots__ = [
 4960        'bind_interface',
 4961        'egress_filter',
 4962        'healthy',
 4963        'hostname',
 4964        'id',
 4965        'name',
 4966        'password',
 4967        'port',
 4968        'port_override',
 4969        'secret_store_id',
 4970        'tags',
 4971        'tls_required',
 4972    ]
 4973
 4974    def __init__(
 4975        self,
 4976        bind_interface=None,
 4977        egress_filter=None,
 4978        healthy=None,
 4979        hostname=None,
 4980        id=None,
 4981        name=None,
 4982        password=None,
 4983        port=None,
 4984        port_override=None,
 4985        secret_store_id=None,
 4986        tags=None,
 4987        tls_required=None,
 4988    ):
 4989        self.bind_interface = bind_interface if bind_interface is not None else ''
 4990        '''
 4991         Bind interface
 4992        '''
 4993        self.egress_filter = egress_filter if egress_filter is not None else ''
 4994        '''
 4995         A filter applied to the routing logic to pin datasource to nodes.
 4996        '''
 4997        self.healthy = healthy if healthy is not None else False
 4998        '''
 4999         True if the datasource is reachable and the credentials are valid.
 5000        '''
 5001        self.hostname = hostname if hostname is not None else ''
 5002        '''
 5003
 5004        '''
 5005        self.id = id if id is not None else ''
 5006        '''
 5007         Unique identifier of the Resource.
 5008        '''
 5009        self.name = name if name is not None else ''
 5010        '''
 5011         Unique human-readable name of the Resource.
 5012        '''
 5013        self.password = password if password is not None else ''
 5014        '''
 5015
 5016        '''
 5017        self.port = port if port is not None else 0
 5018        '''
 5019
 5020        '''
 5021        self.port_override = port_override if port_override is not None else 0
 5022        '''
 5023
 5024        '''
 5025        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 5026        '''
 5027         ID of the secret store containing credentials for this resource, if any.
 5028        '''
 5029        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 5030        '''
 5031         Tags is a map of key, value pairs.
 5032        '''
 5033        self.tls_required = tls_required if tls_required is not None else False
 5034        '''
 5035
 5036        '''
 5037
 5038    def __repr__(self):
 5039        return '<sdm.ElasticacheRedis ' + \
 5040            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 5041            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 5042            'healthy: ' + repr(self.healthy) + ' ' +\
 5043            'hostname: ' + repr(self.hostname) + ' ' +\
 5044            'id: ' + repr(self.id) + ' ' +\
 5045            'name: ' + repr(self.name) + ' ' +\
 5046            'password: ' + repr(self.password) + ' ' +\
 5047            'port: ' + repr(self.port) + ' ' +\
 5048            'port_override: ' + repr(self.port_override) + ' ' +\
 5049            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 5050            'tags: ' + repr(self.tags) + ' ' +\
 5051            'tls_required: ' + repr(self.tls_required) + ' ' +\
 5052            '>'
 5053
 5054    def to_dict(self):
 5055        return {
 5056            'bind_interface': self.bind_interface,
 5057            'egress_filter': self.egress_filter,
 5058            'healthy': self.healthy,
 5059            'hostname': self.hostname,
 5060            'id': self.id,
 5061            'name': self.name,
 5062            'password': self.password,
 5063            'port': self.port,
 5064            'port_override': self.port_override,
 5065            'secret_store_id': self.secret_store_id,
 5066            'tags': self.tags,
 5067            'tls_required': self.tls_required,
 5068        }
 5069
 5070    @classmethod
 5071    def from_dict(cls, d):
 5072        return cls(
 5073            bind_interface=d.get('bind_interface'),
 5074            egress_filter=d.get('egress_filter'),
 5075            healthy=d.get('healthy'),
 5076            hostname=d.get('hostname'),
 5077            id=d.get('id'),
 5078            name=d.get('name'),
 5079            password=d.get('password'),
 5080            port=d.get('port'),
 5081            port_override=d.get('port_override'),
 5082            secret_store_id=d.get('secret_store_id'),
 5083            tags=d.get('tags'),
 5084            tls_required=d.get('tls_required'),
 5085        )
 5086
 5087
 5088class GCP:
 5089    '''
 5090
 5091    '''
 5092    __slots__ = [
 5093        'bind_interface',
 5094        'egress_filter',
 5095        'healthy',
 5096        'id',
 5097        'keyfile',
 5098        'name',
 5099        'scopes',
 5100        'secret_store_id',
 5101        'tags',
 5102    ]
 5103
 5104    def __init__(
 5105        self,
 5106        bind_interface=None,
 5107        egress_filter=None,
 5108        healthy=None,
 5109        id=None,
 5110        keyfile=None,
 5111        name=None,
 5112        scopes=None,
 5113        secret_store_id=None,
 5114        tags=None,
 5115    ):
 5116        self.bind_interface = bind_interface if bind_interface is not None else ''
 5117        '''
 5118         Bind interface
 5119        '''
 5120        self.egress_filter = egress_filter if egress_filter is not None else ''
 5121        '''
 5122         A filter applied to the routing logic to pin datasource to nodes.
 5123        '''
 5124        self.healthy = healthy if healthy is not None else False
 5125        '''
 5126         True if the datasource is reachable and the credentials are valid.
 5127        '''
 5128        self.id = id if id is not None else ''
 5129        '''
 5130         Unique identifier of the Resource.
 5131        '''
 5132        self.keyfile = keyfile if keyfile is not None else ''
 5133        '''
 5134
 5135        '''
 5136        self.name = name if name is not None else ''
 5137        '''
 5138         Unique human-readable name of the Resource.
 5139        '''
 5140        self.scopes = scopes if scopes is not None else ''
 5141        '''
 5142
 5143        '''
 5144        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 5145        '''
 5146         ID of the secret store containing credentials for this resource, if any.
 5147        '''
 5148        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 5149        '''
 5150         Tags is a map of key, value pairs.
 5151        '''
 5152
 5153    def __repr__(self):
 5154        return '<sdm.GCP ' + \
 5155            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 5156            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 5157            'healthy: ' + repr(self.healthy) + ' ' +\
 5158            'id: ' + repr(self.id) + ' ' +\
 5159            'keyfile: ' + repr(self.keyfile) + ' ' +\
 5160            'name: ' + repr(self.name) + ' ' +\
 5161            'scopes: ' + repr(self.scopes) + ' ' +\
 5162            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 5163            'tags: ' + repr(self.tags) + ' ' +\
 5164            '>'
 5165
 5166    def to_dict(self):
 5167        return {
 5168            'bind_interface': self.bind_interface,
 5169            'egress_filter': self.egress_filter,
 5170            'healthy': self.healthy,
 5171            'id': self.id,
 5172            'keyfile': self.keyfile,
 5173            'name': self.name,
 5174            'scopes': self.scopes,
 5175            'secret_store_id': self.secret_store_id,
 5176            'tags': self.tags,
 5177        }
 5178
 5179    @classmethod
 5180    def from_dict(cls, d):
 5181        return cls(
 5182            bind_interface=d.get('bind_interface'),
 5183            egress_filter=d.get('egress_filter'),
 5184            healthy=d.get('healthy'),
 5185            id=d.get('id'),
 5186            keyfile=d.get('keyfile'),
 5187            name=d.get('name'),
 5188            scopes=d.get('scopes'),
 5189            secret_store_id=d.get('secret_store_id'),
 5190            tags=d.get('tags'),
 5191        )
 5192
 5193
 5194class GCPStore:
 5195    '''
 5196
 5197    '''
 5198    __slots__ = [
 5199        'id',
 5200        'name',
 5201        'projectid',
 5202        'tags',
 5203    ]
 5204
 5205    def __init__(
 5206        self,
 5207        id=None,
 5208        name=None,
 5209        projectid=None,
 5210        tags=None,
 5211    ):
 5212        self.id = id if id is not None else ''
 5213        '''
 5214         Unique identifier of the SecretStore.
 5215        '''
 5216        self.name = name if name is not None else ''
 5217        '''
 5218         Unique human-readable name of the SecretStore.
 5219        '''
 5220        self.projectid = projectid if projectid is not None else ''
 5221        '''
 5222
 5223        '''
 5224        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 5225        '''
 5226         Tags is a map of key, value pairs.
 5227        '''
 5228
 5229    def __repr__(self):
 5230        return '<sdm.GCPStore ' + \
 5231            'id: ' + repr(self.id) + ' ' +\
 5232            'name: ' + repr(self.name) + ' ' +\
 5233            'projectid: ' + repr(self.projectid) + ' ' +\
 5234            'tags: ' + repr(self.tags) + ' ' +\
 5235            '>'
 5236
 5237    def to_dict(self):
 5238        return {
 5239            'id': self.id,
 5240            'name': self.name,
 5241            'projectid': self.projectid,
 5242            'tags': self.tags,
 5243        }
 5244
 5245    @classmethod
 5246    def from_dict(cls, d):
 5247        return cls(
 5248            id=d.get('id'),
 5249            name=d.get('name'),
 5250            projectid=d.get('projectid'),
 5251            tags=d.get('tags'),
 5252        )
 5253
 5254
 5255class Gateway:
 5256    '''
 5257     Gateway represents a StrongDM CLI installation running in gateway mode.
 5258    '''
 5259    __slots__ = [
 5260        'bind_address',
 5261        'gateway_filter',
 5262        'id',
 5263        'listen_address',
 5264        'name',
 5265        'state',
 5266        'tags',
 5267    ]
 5268
 5269    def __init__(
 5270        self,
 5271        bind_address=None,
 5272        gateway_filter=None,
 5273        id=None,
 5274        listen_address=None,
 5275        name=None,
 5276        state=None,
 5277        tags=None,
 5278    ):
 5279        self.bind_address = bind_address if bind_address is not None else ''
 5280        '''
 5281         The hostname/port tuple which the gateway daemon will bind to.
 5282         If not provided on create, set to "0.0.0.0:listen_address_port".
 5283        '''
 5284        self.gateway_filter = gateway_filter if gateway_filter is not None else ''
 5285        '''
 5286         GatewayFilter can be used to restrict the peering between relays and
 5287         gateways.
 5288        '''
 5289        self.id = id if id is not None else ''
 5290        '''
 5291         Unique identifier of the Gateway.
 5292        '''
 5293        self.listen_address = listen_address if listen_address is not None else ''
 5294        '''
 5295         The public hostname/port tuple at which the gateway will be accessible to clients.
 5296        '''
 5297        self.name = name if name is not None else ''
 5298        '''
 5299         Unique human-readable name of the Gateway. Node names must include only letters, numbers, and hyphens (no spaces, underscores, or other special characters). Generated if not provided on create.
 5300        '''
 5301        self.state = state if state is not None else ''
 5302        '''
 5303         The current state of the gateway. One of: "new", "verifying_restart",
 5304         "restarting", "started", "stopped", "dead", "unknown"
 5305        '''
 5306        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 5307        '''
 5308         Tags is a map of key, value pairs.
 5309        '''
 5310
 5311    def __repr__(self):
 5312        return '<sdm.Gateway ' + \
 5313            'bind_address: ' + repr(self.bind_address) + ' ' +\
 5314            'gateway_filter: ' + repr(self.gateway_filter) + ' ' +\
 5315            'id: ' + repr(self.id) + ' ' +\
 5316            'listen_address: ' + repr(self.listen_address) + ' ' +\
 5317            'name: ' + repr(self.name) + ' ' +\
 5318            'state: ' + repr(self.state) + ' ' +\
 5319            'tags: ' + repr(self.tags) + ' ' +\
 5320            '>'
 5321
 5322    def to_dict(self):
 5323        return {
 5324            'bind_address': self.bind_address,
 5325            'gateway_filter': self.gateway_filter,
 5326            'id': self.id,
 5327            'listen_address': self.listen_address,
 5328            'name': self.name,
 5329            'state': self.state,
 5330            'tags': self.tags,
 5331        }
 5332
 5333    @classmethod
 5334    def from_dict(cls, d):
 5335        return cls(
 5336            bind_address=d.get('bind_address'),
 5337            gateway_filter=d.get('gateway_filter'),
 5338            id=d.get('id'),
 5339            listen_address=d.get('listen_address'),
 5340            name=d.get('name'),
 5341            state=d.get('state'),
 5342            tags=d.get('tags'),
 5343        )
 5344
 5345
 5346class GetResponseMetadata:
 5347    '''
 5348     GetResponseMetadata is reserved for future use.
 5349    '''
 5350    __slots__ = []
 5351
 5352    def __init__(self, ):
 5353        pass
 5354
 5355    def __repr__(self):
 5356        return '<sdm.GetResponseMetadata ' + \
 5357            '>'
 5358
 5359    def to_dict(self):
 5360        return {}
 5361
 5362    @classmethod
 5363    def from_dict(cls, d):
 5364        return cls()
 5365
 5366
 5367class GoogleGKE:
 5368    '''
 5369
 5370    '''
 5371    __slots__ = [
 5372        'bind_interface',
 5373        'certificate_authority',
 5374        'egress_filter',
 5375        'endpoint',
 5376        'healthcheck_namespace',
 5377        'healthy',
 5378        'id',
 5379        'name',
 5380        'remote_identity_group_id',
 5381        'remote_identity_healthcheck_username',
 5382        'secret_store_id',
 5383        'service_account_key',
 5384        'tags',
 5385    ]
 5386
 5387    def __init__(
 5388        self,
 5389        bind_interface=None,
 5390        certificate_authority=None,
 5391        egress_filter=None,
 5392        endpoint=None,
 5393        healthcheck_namespace=None,
 5394        healthy=None,
 5395        id=None,
 5396        name=None,
 5397        remote_identity_group_id=None,
 5398        remote_identity_healthcheck_username=None,
 5399        secret_store_id=None,
 5400        service_account_key=None,
 5401        tags=None,
 5402    ):
 5403        self.bind_interface = bind_interface if bind_interface is not None else ''
 5404        '''
 5405         Bind interface
 5406        '''
 5407        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 5408        '''
 5409
 5410        '''
 5411        self.egress_filter = egress_filter if egress_filter is not None else ''
 5412        '''
 5413         A filter applied to the routing logic to pin datasource to nodes.
 5414        '''
 5415        self.endpoint = endpoint if endpoint is not None else ''
 5416        '''
 5417
 5418        '''
 5419        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 5420        '''
 5421         The path used to check the health of your connection.  Defaults to `default`.
 5422        '''
 5423        self.healthy = healthy if healthy is not None else False
 5424        '''
 5425         True if the datasource is reachable and the credentials are valid.
 5426        '''
 5427        self.id = id if id is not None else ''
 5428        '''
 5429         Unique identifier of the Resource.
 5430        '''
 5431        self.name = name if name is not None else ''
 5432        '''
 5433         Unique human-readable name of the Resource.
 5434        '''
 5435        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
 5436        '''
 5437
 5438        '''
 5439        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
 5440        '''
 5441
 5442        '''
 5443        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 5444        '''
 5445         ID of the secret store containing credentials for this resource, if any.
 5446        '''
 5447        self.service_account_key = service_account_key if service_account_key is not None else ''
 5448        '''
 5449
 5450        '''
 5451        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 5452        '''
 5453         Tags is a map of key, value pairs.
 5454        '''
 5455
 5456    def __repr__(self):
 5457        return '<sdm.GoogleGKE ' + \
 5458            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 5459            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
 5460            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 5461            'endpoint: ' + repr(self.endpoint) + ' ' +\
 5462            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 5463            'healthy: ' + repr(self.healthy) + ' ' +\
 5464            'id: ' + repr(self.id) + ' ' +\
 5465            'name: ' + repr(self.name) + ' ' +\
 5466            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
 5467            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
 5468            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 5469            'service_account_key: ' + repr(self.service_account_key) + ' ' +\
 5470            'tags: ' + repr(self.tags) + ' ' +\
 5471            '>'
 5472
 5473    def to_dict(self):
 5474        return {
 5475            'bind_interface': self.bind_interface,
 5476            'certificate_authority': self.certificate_authority,
 5477            'egress_filter': self.egress_filter,
 5478            'endpoint': self.endpoint,
 5479            'healthcheck_namespace': self.healthcheck_namespace,
 5480            'healthy': self.healthy,
 5481            'id': self.id,
 5482            'name': self.name,
 5483            'remote_identity_group_id': self.remote_identity_group_id,
 5484            'remote_identity_healthcheck_username':
 5485            self.remote_identity_healthcheck_username,
 5486            'secret_store_id': self.secret_store_id,
 5487            'service_account_key': self.service_account_key,
 5488            'tags': self.tags,
 5489        }
 5490
 5491    @classmethod
 5492    def from_dict(cls, d):
 5493        return cls(
 5494            bind_interface=d.get('bind_interface'),
 5495            certificate_authority=d.get('certificate_authority'),
 5496            egress_filter=d.get('egress_filter'),
 5497            endpoint=d.get('endpoint'),
 5498            healthcheck_namespace=d.get('healthcheck_namespace'),
 5499            healthy=d.get('healthy'),
 5500            id=d.get('id'),
 5501            name=d.get('name'),
 5502            remote_identity_group_id=d.get('remote_identity_group_id'),
 5503            remote_identity_healthcheck_username=d.get(
 5504                'remote_identity_healthcheck_username'),
 5505            secret_store_id=d.get('secret_store_id'),
 5506            service_account_key=d.get('service_account_key'),
 5507            tags=d.get('tags'),
 5508        )
 5509
 5510
 5511class GoogleGKEUserImpersonation:
 5512    '''
 5513
 5514    '''
 5515    __slots__ = [
 5516        'bind_interface',
 5517        'certificate_authority',
 5518        'egress_filter',
 5519        'endpoint',
 5520        'healthcheck_namespace',
 5521        'healthy',
 5522        'id',
 5523        'name',
 5524        'secret_store_id',
 5525        'service_account_key',
 5526        'tags',
 5527    ]
 5528
 5529    def __init__(
 5530        self,
 5531        bind_interface=None,
 5532        certificate_authority=None,
 5533        egress_filter=None,
 5534        endpoint=None,
 5535        healthcheck_namespace=None,
 5536        healthy=None,
 5537        id=None,
 5538        name=None,
 5539        secret_store_id=None,
 5540        service_account_key=None,
 5541        tags=None,
 5542    ):
 5543        self.bind_interface = bind_interface if bind_interface is not None else ''
 5544        '''
 5545         Bind interface
 5546        '''
 5547        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 5548        '''
 5549
 5550        '''
 5551        self.egress_filter = egress_filter if egress_filter is not None else ''
 5552        '''
 5553         A filter applied to the routing logic to pin datasource to nodes.
 5554        '''
 5555        self.endpoint = endpoint if endpoint is not None else ''
 5556        '''
 5557
 5558        '''
 5559        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 5560        '''
 5561         The path used to check the health of your connection.  Defaults to `default`.
 5562        '''
 5563        self.healthy = healthy if healthy is not None else False
 5564        '''
 5565         True if the datasource is reachable and the credentials are valid.
 5566        '''
 5567        self.id = id if id is not None else ''
 5568        '''
 5569         Unique identifier of the Resource.
 5570        '''
 5571        self.name = name if name is not None else ''
 5572        '''
 5573         Unique human-readable name of the Resource.
 5574        '''
 5575        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 5576        '''
 5577         ID of the secret store containing credentials for this resource, if any.
 5578        '''
 5579        self.service_account_key = service_account_key if service_account_key is not None else ''
 5580        '''
 5581
 5582        '''
 5583        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 5584        '''
 5585         Tags is a map of key, value pairs.
 5586        '''
 5587
 5588    def __repr__(self):
 5589        return '<sdm.GoogleGKEUserImpersonation ' + \
 5590            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 5591            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
 5592            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 5593            'endpoint: ' + repr(self.endpoint) + ' ' +\
 5594            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 5595            'healthy: ' + repr(self.healthy) + ' ' +\
 5596            'id: ' + repr(self.id) + ' ' +\
 5597            'name: ' + repr(self.name) + ' ' +\
 5598            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 5599            'service_account_key: ' + repr(self.service_account_key) + ' ' +\
 5600            'tags: ' + repr(self.tags) + ' ' +\
 5601            '>'
 5602
 5603    def to_dict(self):
 5604        return {
 5605            'bind_interface': self.bind_interface,
 5606            'certificate_authority': self.certificate_authority,
 5607            'egress_filter': self.egress_filter,
 5608            'endpoint': self.endpoint,
 5609            'healthcheck_namespace': self.healthcheck_namespace,
 5610            'healthy': self.healthy,
 5611            'id': self.id,
 5612            'name': self.name,
 5613            'secret_store_id': self.secret_store_id,
 5614            'service_account_key': self.service_account_key,
 5615            'tags': self.tags,
 5616        }
 5617
 5618    @classmethod
 5619    def from_dict(cls, d):
 5620        return cls(
 5621            bind_interface=d.get('bind_interface'),
 5622            certificate_authority=d.get('certificate_authority'),
 5623            egress_filter=d.get('egress_filter'),
 5624            endpoint=d.get('endpoint'),
 5625            healthcheck_namespace=d.get('healthcheck_namespace'),
 5626            healthy=d.get('healthy'),
 5627            id=d.get('id'),
 5628            name=d.get('name'),
 5629            secret_store_id=d.get('secret_store_id'),
 5630            service_account_key=d.get('service_account_key'),
 5631            tags=d.get('tags'),
 5632        )
 5633
 5634
 5635class Greenplum:
 5636    '''
 5637
 5638    '''
 5639    __slots__ = [
 5640        'bind_interface',
 5641        'database',
 5642        'egress_filter',
 5643        'healthy',
 5644        'hostname',
 5645        'id',
 5646        'name',
 5647        'override_database',
 5648        'password',
 5649        'port',
 5650        'port_override',
 5651        'secret_store_id',
 5652        'tags',
 5653        'username',
 5654    ]
 5655
 5656    def __init__(
 5657        self,
 5658        bind_interface=None,
 5659        database=None,
 5660        egress_filter=None,
 5661        healthy=None,
 5662        hostname=None,
 5663        id=None,
 5664        name=None,
 5665        override_database=None,
 5666        password=None,
 5667        port=None,
 5668        port_override=None,
 5669        secret_store_id=None,
 5670        tags=None,
 5671        username=None,
 5672    ):
 5673        self.bind_interface = bind_interface if bind_interface is not None else ''
 5674        '''
 5675         Bind interface
 5676        '''
 5677        self.database = database if database is not None else ''
 5678        '''
 5679
 5680        '''
 5681        self.egress_filter = egress_filter if egress_filter is not None else ''
 5682        '''
 5683         A filter applied to the routing logic to pin datasource to nodes.
 5684        '''
 5685        self.healthy = healthy if healthy is not None else False
 5686        '''
 5687         True if the datasource is reachable and the credentials are valid.
 5688        '''
 5689        self.hostname = hostname if hostname is not None else ''
 5690        '''
 5691
 5692        '''
 5693        self.id = id if id is not None else ''
 5694        '''
 5695         Unique identifier of the Resource.
 5696        '''
 5697        self.name = name if name is not None else ''
 5698        '''
 5699         Unique human-readable name of the Resource.
 5700        '''
 5701        self.override_database = override_database if override_database is not None else False
 5702        '''
 5703
 5704        '''
 5705        self.password = password if password is not None else ''
 5706        '''
 5707
 5708        '''
 5709        self.port = port if port is not None else 0
 5710        '''
 5711
 5712        '''
 5713        self.port_override = port_override if port_override is not None else 0
 5714        '''
 5715
 5716        '''
 5717        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 5718        '''
 5719         ID of the secret store containing credentials for this resource, if any.
 5720        '''
 5721        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 5722        '''
 5723         Tags is a map of key, value pairs.
 5724        '''
 5725        self.username = username if username is not None else ''
 5726        '''
 5727
 5728        '''
 5729
 5730    def __repr__(self):
 5731        return '<sdm.Greenplum ' + \
 5732            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 5733            'database: ' + repr(self.database) + ' ' +\
 5734            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 5735            'healthy: ' + repr(self.healthy) + ' ' +\
 5736            'hostname: ' + repr(self.hostname) + ' ' +\
 5737            'id: ' + repr(self.id) + ' ' +\
 5738            'name: ' + repr(self.name) + ' ' +\
 5739            'override_database: ' + repr(self.override_database) + ' ' +\
 5740            'password: ' + repr(self.password) + ' ' +\
 5741            'port: ' + repr(self.port) + ' ' +\
 5742            'port_override: ' + repr(self.port_override) + ' ' +\
 5743            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 5744            'tags: ' + repr(self.tags) + ' ' +\
 5745            'username: ' + repr(self.username) + ' ' +\
 5746            '>'
 5747
 5748    def to_dict(self):
 5749        return {
 5750            'bind_interface': self.bind_interface,
 5751            'database': self.database,
 5752            'egress_filter': self.egress_filter,
 5753            'healthy': self.healthy,
 5754            'hostname': self.hostname,
 5755            'id': self.id,
 5756            'name': self.name,
 5757            'override_database': self.override_database,
 5758            'password': self.password,
 5759            'port': self.port,
 5760            'port_override': self.port_override,
 5761            'secret_store_id': self.secret_store_id,
 5762            'tags': self.tags,
 5763            'username': self.username,
 5764        }
 5765
 5766    @classmethod
 5767    def from_dict(cls, d):
 5768        return cls(
 5769            bind_interface=d.get('bind_interface'),
 5770            database=d.get('database'),
 5771            egress_filter=d.get('egress_filter'),
 5772            healthy=d.get('healthy'),
 5773            hostname=d.get('hostname'),
 5774            id=d.get('id'),
 5775            name=d.get('name'),
 5776            override_database=d.get('override_database'),
 5777            password=d.get('password'),
 5778            port=d.get('port'),
 5779            port_override=d.get('port_override'),
 5780            secret_store_id=d.get('secret_store_id'),
 5781            tags=d.get('tags'),
 5782            username=d.get('username'),
 5783        )
 5784
 5785
 5786class HTTPAuth:
 5787    '''
 5788
 5789    '''
 5790    __slots__ = [
 5791        'auth_header',
 5792        'bind_interface',
 5793        'default_path',
 5794        'egress_filter',
 5795        'headers_blacklist',
 5796        'healthcheck_path',
 5797        'healthy',
 5798        'id',
 5799        'name',
 5800        'secret_store_id',
 5801        'subdomain',
 5802        'tags',
 5803        'url',
 5804    ]
 5805
 5806    def __init__(
 5807        self,
 5808        auth_header=None,
 5809        bind_interface=None,
 5810        default_path=None,
 5811        egress_filter=None,
 5812        headers_blacklist=None,
 5813        healthcheck_path=None,
 5814        healthy=None,
 5815        id=None,
 5816        name=None,
 5817        secret_store_id=None,
 5818        subdomain=None,
 5819        tags=None,
 5820        url=None,
 5821    ):
 5822        self.auth_header = auth_header if auth_header is not None else ''
 5823        '''
 5824
 5825        '''
 5826        self.bind_interface = bind_interface if bind_interface is not None else ''
 5827        '''
 5828         Bind interface
 5829        '''
 5830        self.default_path = default_path if default_path is not None else ''
 5831        '''
 5832
 5833        '''
 5834        self.egress_filter = egress_filter if egress_filter is not None else ''
 5835        '''
 5836         A filter applied to the routing logic to pin datasource to nodes.
 5837        '''
 5838        self.headers_blacklist = headers_blacklist if headers_blacklist is not None else ''
 5839        '''
 5840
 5841        '''
 5842        self.healthcheck_path = healthcheck_path if healthcheck_path is not None else ''
 5843        '''
 5844
 5845        '''
 5846        self.healthy = healthy if healthy is not None else False
 5847        '''
 5848         True if the datasource is reachable and the credentials are valid.
 5849        '''
 5850        self.id = id if id is not None else ''
 5851        '''
 5852         Unique identifier of the Resource.
 5853        '''
 5854        self.name = name if name is not None else ''
 5855        '''
 5856         Unique human-readable name of the Resource.
 5857        '''
 5858        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 5859        '''
 5860         ID of the secret store containing credentials for this resource, if any.
 5861        '''
 5862        self.subdomain = subdomain if subdomain is not None else ''
 5863        '''
 5864
 5865        '''
 5866        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 5867        '''
 5868         Tags is a map of key, value pairs.
 5869        '''
 5870        self.url = url if url is not None else ''
 5871        '''
 5872
 5873        '''
 5874
 5875    def __repr__(self):
 5876        return '<sdm.HTTPAuth ' + \
 5877            'auth_header: ' + repr(self.auth_header) + ' ' +\
 5878            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 5879            'default_path: ' + repr(self.default_path) + ' ' +\
 5880            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 5881            'headers_blacklist: ' + repr(self.headers_blacklist) + ' ' +\
 5882            'healthcheck_path: ' + repr(self.healthcheck_path) + ' ' +\
 5883            'healthy: ' + repr(self.healthy) + ' ' +\
 5884            'id: ' + repr(self.id) + ' ' +\
 5885            'name: ' + repr(self.name) + ' ' +\
 5886            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 5887            'subdomain: ' + repr(self.subdomain) + ' ' +\
 5888            'tags: ' + repr(self.tags) + ' ' +\
 5889            'url: ' + repr(self.url) + ' ' +\
 5890            '>'
 5891
 5892    def to_dict(self):
 5893        return {
 5894            'auth_header': self.auth_header,
 5895            'bind_interface': self.bind_interface,
 5896            'default_path': self.default_path,
 5897            'egress_filter': self.egress_filter,
 5898            'headers_blacklist': self.headers_blacklist,
 5899            'healthcheck_path': self.healthcheck_path,
 5900            'healthy': self.healthy,
 5901            'id': self.id,
 5902            'name': self.name,
 5903            'secret_store_id': self.secret_store_id,
 5904            'subdomain': self.subdomain,
 5905            'tags': self.tags,
 5906            'url': self.url,
 5907        }
 5908
 5909    @classmethod
 5910    def from_dict(cls, d):
 5911        return cls(
 5912            auth_header=d.get('auth_header'),
 5913            bind_interface=d.get('bind_interface'),
 5914            default_path=d.get('default_path'),
 5915            egress_filter=d.get('egress_filter'),
 5916            headers_blacklist=d.get('headers_blacklist'),
 5917            healthcheck_path=d.get('healthcheck_path'),
 5918            healthy=d.get('healthy'),
 5919            id=d.get('id'),
 5920            name=d.get('name'),
 5921            secret_store_id=d.get('secret_store_id'),
 5922            subdomain=d.get('subdomain'),
 5923            tags=d.get('tags'),
 5924            url=d.get('url'),
 5925        )
 5926
 5927
 5928class HTTPBasicAuth:
 5929    '''
 5930
 5931    '''
 5932    __slots__ = [
 5933        'bind_interface',
 5934        'default_path',
 5935        'egress_filter',
 5936        'headers_blacklist',
 5937        'healthcheck_path',
 5938        'healthy',
 5939        'id',
 5940        'name',
 5941        'password',
 5942        'secret_store_id',
 5943        'subdomain',
 5944        'tags',
 5945        'url',
 5946        'username',
 5947    ]
 5948
 5949    def __init__(
 5950        self,
 5951        bind_interface=None,
 5952        default_path=None,
 5953        egress_filter=None,
 5954        headers_blacklist=None,
 5955        healthcheck_path=None,
 5956        healthy=None,
 5957        id=None,
 5958        name=None,
 5959        password=None,
 5960        secret_store_id=None,
 5961        subdomain=None,
 5962        tags=None,
 5963        url=None,
 5964        username=None,
 5965    ):
 5966        self.bind_interface = bind_interface if bind_interface is not None else ''
 5967        '''
 5968         Bind interface
 5969        '''
 5970        self.default_path = default_path if default_path is not None else ''
 5971        '''
 5972
 5973        '''
 5974        self.egress_filter = egress_filter if egress_filter is not None else ''
 5975        '''
 5976         A filter applied to the routing logic to pin datasource to nodes.
 5977        '''
 5978        self.headers_blacklist = headers_blacklist if headers_blacklist is not None else ''
 5979        '''
 5980
 5981        '''
 5982        self.healthcheck_path = healthcheck_path if healthcheck_path is not None else ''
 5983        '''
 5984
 5985        '''
 5986        self.healthy = healthy if healthy is not None else False
 5987        '''
 5988         True if the datasource is reachable and the credentials are valid.
 5989        '''
 5990        self.id = id if id is not None else ''
 5991        '''
 5992         Unique identifier of the Resource.
 5993        '''
 5994        self.name = name if name is not None else ''
 5995        '''
 5996         Unique human-readable name of the Resource.
 5997        '''
 5998        self.password = password if password is not None else ''
 5999        '''
 6000
 6001        '''
 6002        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 6003        '''
 6004         ID of the secret store containing credentials for this resource, if any.
 6005        '''
 6006        self.subdomain = subdomain if subdomain is not None else ''
 6007        '''
 6008
 6009        '''
 6010        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 6011        '''
 6012         Tags is a map of key, value pairs.
 6013        '''
 6014        self.url = url if url is not None else ''
 6015        '''
 6016
 6017        '''
 6018        self.username = username if username is not None else ''
 6019        '''
 6020
 6021        '''
 6022
 6023    def __repr__(self):
 6024        return '<sdm.HTTPBasicAuth ' + \
 6025            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 6026            'default_path: ' + repr(self.default_path) + ' ' +\
 6027            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 6028            'headers_blacklist: ' + repr(self.headers_blacklist) + ' ' +\
 6029            'healthcheck_path: ' + repr(self.healthcheck_path) + ' ' +\
 6030            'healthy: ' + repr(self.healthy) + ' ' +\
 6031            'id: ' + repr(self.id) + ' ' +\
 6032            'name: ' + repr(self.name) + ' ' +\
 6033            'password: ' + repr(self.password) + ' ' +\
 6034            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 6035            'subdomain: ' + repr(self.subdomain) + ' ' +\
 6036            'tags: ' + repr(self.tags) + ' ' +\
 6037            'url: ' + repr(self.url) + ' ' +\
 6038            'username: ' + repr(self.username) + ' ' +\
 6039            '>'
 6040
 6041    def to_dict(self):
 6042        return {
 6043            'bind_interface': self.bind_interface,
 6044            'default_path': self.default_path,
 6045            'egress_filter': self.egress_filter,
 6046            'headers_blacklist': self.headers_blacklist,
 6047            'healthcheck_path': self.healthcheck_path,
 6048            'healthy': self.healthy,
 6049            'id': self.id,
 6050            'name': self.name,
 6051            'password': self.password,
 6052            'secret_store_id': self.secret_store_id,
 6053            'subdomain': self.subdomain,
 6054            'tags': self.tags,
 6055            'url': self.url,
 6056            'username': self.username,
 6057        }
 6058
 6059    @classmethod
 6060    def from_dict(cls, d):
 6061        return cls(
 6062            bind_interface=d.get('bind_interface'),
 6063            default_path=d.get('default_path'),
 6064            egress_filter=d.get('egress_filter'),
 6065            headers_blacklist=d.get('headers_blacklist'),
 6066            healthcheck_path=d.get('healthcheck_path'),
 6067            healthy=d.get('healthy'),
 6068            id=d.get('id'),
 6069            name=d.get('name'),
 6070            password=d.get('password'),
 6071            secret_store_id=d.get('secret_store_id'),
 6072            subdomain=d.get('subdomain'),
 6073            tags=d.get('tags'),
 6074            url=d.get('url'),
 6075            username=d.get('username'),
 6076        )
 6077
 6078
 6079class HTTPNoAuth:
 6080    '''
 6081
 6082    '''
 6083    __slots__ = [
 6084        'bind_interface',
 6085        'default_path',
 6086        'egress_filter',
 6087        'headers_blacklist',
 6088        'healthcheck_path',
 6089        'healthy',
 6090        'id',
 6091        'name',
 6092        'secret_store_id',
 6093        'subdomain',
 6094        'tags',
 6095        'url',
 6096    ]
 6097
 6098    def __init__(
 6099        self,
 6100        bind_interface=None,
 6101        default_path=None,
 6102        egress_filter=None,
 6103        headers_blacklist=None,
 6104        healthcheck_path=None,
 6105        healthy=None,
 6106        id=None,
 6107        name=None,
 6108        secret_store_id=None,
 6109        subdomain=None,
 6110        tags=None,
 6111        url=None,
 6112    ):
 6113        self.bind_interface = bind_interface if bind_interface is not None else ''
 6114        '''
 6115         Bind interface
 6116        '''
 6117        self.default_path = default_path if default_path is not None else ''
 6118        '''
 6119
 6120        '''
 6121        self.egress_filter = egress_filter if egress_filter is not None else ''
 6122        '''
 6123         A filter applied to the routing logic to pin datasource to nodes.
 6124        '''
 6125        self.headers_blacklist = headers_blacklist if headers_blacklist is not None else ''
 6126        '''
 6127
 6128        '''
 6129        self.healthcheck_path = healthcheck_path if healthcheck_path is not None else ''
 6130        '''
 6131
 6132        '''
 6133        self.healthy = healthy if healthy is not None else False
 6134        '''
 6135         True if the datasource is reachable and the credentials are valid.
 6136        '''
 6137        self.id = id if id is not None else ''
 6138        '''
 6139         Unique identifier of the Resource.
 6140        '''
 6141        self.name = name if name is not None else ''
 6142        '''
 6143         Unique human-readable name of the Resource.
 6144        '''
 6145        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 6146        '''
 6147         ID of the secret store containing credentials for this resource, if any.
 6148        '''
 6149        self.subdomain = subdomain if subdomain is not None else ''
 6150        '''
 6151
 6152        '''
 6153        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 6154        '''
 6155         Tags is a map of key, value pairs.
 6156        '''
 6157        self.url = url if url is not None else ''
 6158        '''
 6159
 6160        '''
 6161
 6162    def __repr__(self):
 6163        return '<sdm.HTTPNoAuth ' + \
 6164            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 6165            'default_path: ' + repr(self.default_path) + ' ' +\
 6166            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 6167            'headers_blacklist: ' + repr(self.headers_blacklist) + ' ' +\
 6168            'healthcheck_path: ' + repr(self.healthcheck_path) + ' ' +\
 6169            'healthy: ' + repr(self.healthy) + ' ' +\
 6170            'id: ' + repr(self.id) + ' ' +\
 6171            'name: ' + repr(self.name) + ' ' +\
 6172            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 6173            'subdomain: ' + repr(self.subdomain) + ' ' +\
 6174            'tags: ' + repr(self.tags) + ' ' +\
 6175            'url: ' + repr(self.url) + ' ' +\
 6176            '>'
 6177
 6178    def to_dict(self):
 6179        return {
 6180            'bind_interface': self.bind_interface,
 6181            'default_path': self.default_path,
 6182            'egress_filter': self.egress_filter,
 6183            'headers_blacklist': self.headers_blacklist,
 6184            'healthcheck_path': self.healthcheck_path,
 6185            'healthy': self.healthy,
 6186            'id': self.id,
 6187            'name': self.name,
 6188            'secret_store_id': self.secret_store_id,
 6189            'subdomain': self.subdomain,
 6190            'tags': self.tags,
 6191            'url': self.url,
 6192        }
 6193
 6194    @classmethod
 6195    def from_dict(cls, d):
 6196        return cls(
 6197            bind_interface=d.get('bind_interface'),
 6198            default_path=d.get('default_path'),
 6199            egress_filter=d.get('egress_filter'),
 6200            headers_blacklist=d.get('headers_blacklist'),
 6201            healthcheck_path=d.get('healthcheck_path'),
 6202            healthy=d.get('healthy'),
 6203            id=d.get('id'),
 6204            name=d.get('name'),
 6205            secret_store_id=d.get('secret_store_id'),
 6206            subdomain=d.get('subdomain'),
 6207            tags=d.get('tags'),
 6208            url=d.get('url'),
 6209        )
 6210
 6211
 6212class Kubernetes:
 6213    '''
 6214
 6215    '''
 6216    __slots__ = [
 6217        'bind_interface',
 6218        'certificate_authority',
 6219        'client_certificate',
 6220        'client_key',
 6221        'egress_filter',
 6222        'healthcheck_namespace',
 6223        'healthy',
 6224        'hostname',
 6225        'id',
 6226        'name',
 6227        'port',
 6228        'remote_identity_group_id',
 6229        'remote_identity_healthcheck_username',
 6230        'secret_store_id',
 6231        'tags',
 6232    ]
 6233
 6234    def __init__(
 6235        self,
 6236        bind_interface=None,
 6237        certificate_authority=None,
 6238        client_certificate=None,
 6239        client_key=None,
 6240        egress_filter=None,
 6241        healthcheck_namespace=None,
 6242        healthy=None,
 6243        hostname=None,
 6244        id=None,
 6245        name=None,
 6246        port=None,
 6247        remote_identity_group_id=None,
 6248        remote_identity_healthcheck_username=None,
 6249        secret_store_id=None,
 6250        tags=None,
 6251    ):
 6252        self.bind_interface = bind_interface if bind_interface is not None else ''
 6253        '''
 6254         Bind interface
 6255        '''
 6256        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 6257        '''
 6258
 6259        '''
 6260        self.client_certificate = client_certificate if client_certificate is not None else ''
 6261        '''
 6262
 6263        '''
 6264        self.client_key = client_key if client_key is not None else ''
 6265        '''
 6266
 6267        '''
 6268        self.egress_filter = egress_filter if egress_filter is not None else ''
 6269        '''
 6270         A filter applied to the routing logic to pin datasource to nodes.
 6271        '''
 6272        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 6273        '''
 6274         The path used to check the health of your connection.  Defaults to `default`.
 6275        '''
 6276        self.healthy = healthy if healthy is not None else False
 6277        '''
 6278         True if the datasource is reachable and the credentials are valid.
 6279        '''
 6280        self.hostname = hostname if hostname is not None else ''
 6281        '''
 6282
 6283        '''
 6284        self.id = id if id is not None else ''
 6285        '''
 6286         Unique identifier of the Resource.
 6287        '''
 6288        self.name = name if name is not None else ''
 6289        '''
 6290         Unique human-readable name of the Resource.
 6291        '''
 6292        self.port = port if port is not None else 0
 6293        '''
 6294
 6295        '''
 6296        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
 6297        '''
 6298
 6299        '''
 6300        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
 6301        '''
 6302
 6303        '''
 6304        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 6305        '''
 6306         ID of the secret store containing credentials for this resource, if any.
 6307        '''
 6308        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 6309        '''
 6310         Tags is a map of key, value pairs.
 6311        '''
 6312
 6313    def __repr__(self):
 6314        return '<sdm.Kubernetes ' + \
 6315            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 6316            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
 6317            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
 6318            'client_key: ' + repr(self.client_key) + ' ' +\
 6319            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 6320            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 6321            'healthy: ' + repr(self.healthy) + ' ' +\
 6322            'hostname: ' + repr(self.hostname) + ' ' +\
 6323            'id: ' + repr(self.id) + ' ' +\
 6324            'name: ' + repr(self.name) + ' ' +\
 6325            'port: ' + repr(self.port) + ' ' +\
 6326            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
 6327            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
 6328            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 6329            'tags: ' + repr(self.tags) + ' ' +\
 6330            '>'
 6331
 6332    def to_dict(self):
 6333        return {
 6334            'bind_interface': self.bind_interface,
 6335            'certificate_authority': self.certificate_authority,
 6336            'client_certificate': self.client_certificate,
 6337            'client_key': self.client_key,
 6338            'egress_filter': self.egress_filter,
 6339            'healthcheck_namespace': self.healthcheck_namespace,
 6340            'healthy': self.healthy,
 6341            'hostname': self.hostname,
 6342            'id': self.id,
 6343            'name': self.name,
 6344            'port': self.port,
 6345            'remote_identity_group_id': self.remote_identity_group_id,
 6346            'remote_identity_healthcheck_username':
 6347            self.remote_identity_healthcheck_username,
 6348            'secret_store_id': self.secret_store_id,
 6349            'tags': self.tags,
 6350        }
 6351
 6352    @classmethod
 6353    def from_dict(cls, d):
 6354        return cls(
 6355            bind_interface=d.get('bind_interface'),
 6356            certificate_authority=d.get('certificate_authority'),
 6357            client_certificate=d.get('client_certificate'),
 6358            client_key=d.get('client_key'),
 6359            egress_filter=d.get('egress_filter'),
 6360            healthcheck_namespace=d.get('healthcheck_namespace'),
 6361            healthy=d.get('healthy'),
 6362            hostname=d.get('hostname'),
 6363            id=d.get('id'),
 6364            name=d.get('name'),
 6365            port=d.get('port'),
 6366            remote_identity_group_id=d.get('remote_identity_group_id'),
 6367            remote_identity_healthcheck_username=d.get(
 6368                'remote_identity_healthcheck_username'),
 6369            secret_store_id=d.get('secret_store_id'),
 6370            tags=d.get('tags'),
 6371        )
 6372
 6373
 6374class KubernetesBasicAuth:
 6375    '''
 6376
 6377    '''
 6378    __slots__ = [
 6379        'bind_interface',
 6380        'egress_filter',
 6381        'healthcheck_namespace',
 6382        'healthy',
 6383        'hostname',
 6384        'id',
 6385        'name',
 6386        'password',
 6387        'port',
 6388        'secret_store_id',
 6389        'tags',
 6390        'username',
 6391    ]
 6392
 6393    def __init__(
 6394        self,
 6395        bind_interface=None,
 6396        egress_filter=None,
 6397        healthcheck_namespace=None,
 6398        healthy=None,
 6399        hostname=None,
 6400        id=None,
 6401        name=None,
 6402        password=None,
 6403        port=None,
 6404        secret_store_id=None,
 6405        tags=None,
 6406        username=None,
 6407    ):
 6408        self.bind_interface = bind_interface if bind_interface is not None else ''
 6409        '''
 6410         Bind interface
 6411        '''
 6412        self.egress_filter = egress_filter if egress_filter is not None else ''
 6413        '''
 6414         A filter applied to the routing logic to pin datasource to nodes.
 6415        '''
 6416        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 6417        '''
 6418         The path used to check the health of your connection.  Defaults to `default`.
 6419        '''
 6420        self.healthy = healthy if healthy is not None else False
 6421        '''
 6422         True if the datasource is reachable and the credentials are valid.
 6423        '''
 6424        self.hostname = hostname if hostname is not None else ''
 6425        '''
 6426
 6427        '''
 6428        self.id = id if id is not None else ''
 6429        '''
 6430         Unique identifier of the Resource.
 6431        '''
 6432        self.name = name if name is not None else ''
 6433        '''
 6434         Unique human-readable name of the Resource.
 6435        '''
 6436        self.password = password if password is not None else ''
 6437        '''
 6438
 6439        '''
 6440        self.port = port if port is not None else 0
 6441        '''
 6442
 6443        '''
 6444        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 6445        '''
 6446         ID of the secret store containing credentials for this resource, if any.
 6447        '''
 6448        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 6449        '''
 6450         Tags is a map of key, value pairs.
 6451        '''
 6452        self.username = username if username is not None else ''
 6453        '''
 6454
 6455        '''
 6456
 6457    def __repr__(self):
 6458        return '<sdm.KubernetesBasicAuth ' + \
 6459            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 6460            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 6461            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 6462            'healthy: ' + repr(self.healthy) + ' ' +\
 6463            'hostname: ' + repr(self.hostname) + ' ' +\
 6464            'id: ' + repr(self.id) + ' ' +\
 6465            'name: ' + repr(self.name) + ' ' +\
 6466            'password: ' + repr(self.password) + ' ' +\
 6467            'port: ' + repr(self.port) + ' ' +\
 6468            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 6469            'tags: ' + repr(self.tags) + ' ' +\
 6470            'username: ' + repr(self.username) + ' ' +\
 6471            '>'
 6472
 6473    def to_dict(self):
 6474        return {
 6475            'bind_interface': self.bind_interface,
 6476            'egress_filter': self.egress_filter,
 6477            'healthcheck_namespace': self.healthcheck_namespace,
 6478            'healthy': self.healthy,
 6479            'hostname': self.hostname,
 6480            'id': self.id,
 6481            'name': self.name,
 6482            'password': self.password,
 6483            'port': self.port,
 6484            'secret_store_id': self.secret_store_id,
 6485            'tags': self.tags,
 6486            'username': self.username,
 6487        }
 6488
 6489    @classmethod
 6490    def from_dict(cls, d):
 6491        return cls(
 6492            bind_interface=d.get('bind_interface'),
 6493            egress_filter=d.get('egress_filter'),
 6494            healthcheck_namespace=d.get('healthcheck_namespace'),
 6495            healthy=d.get('healthy'),
 6496            hostname=d.get('hostname'),
 6497            id=d.get('id'),
 6498            name=d.get('name'),
 6499            password=d.get('password'),
 6500            port=d.get('port'),
 6501            secret_store_id=d.get('secret_store_id'),
 6502            tags=d.get('tags'),
 6503            username=d.get('username'),
 6504        )
 6505
 6506
 6507class KubernetesServiceAccount:
 6508    '''
 6509
 6510    '''
 6511    __slots__ = [
 6512        'bind_interface',
 6513        'egress_filter',
 6514        'healthcheck_namespace',
 6515        'healthy',
 6516        'hostname',
 6517        'id',
 6518        'name',
 6519        'port',
 6520        'remote_identity_group_id',
 6521        'remote_identity_healthcheck_username',
 6522        'secret_store_id',
 6523        'tags',
 6524        'token',
 6525    ]
 6526
 6527    def __init__(
 6528        self,
 6529        bind_interface=None,
 6530        egress_filter=None,
 6531        healthcheck_namespace=None,
 6532        healthy=None,
 6533        hostname=None,
 6534        id=None,
 6535        name=None,
 6536        port=None,
 6537        remote_identity_group_id=None,
 6538        remote_identity_healthcheck_username=None,
 6539        secret_store_id=None,
 6540        tags=None,
 6541        token=None,
 6542    ):
 6543        self.bind_interface = bind_interface if bind_interface is not None else ''
 6544        '''
 6545         Bind interface
 6546        '''
 6547        self.egress_filter = egress_filter if egress_filter is not None else ''
 6548        '''
 6549         A filter applied to the routing logic to pin datasource to nodes.
 6550        '''
 6551        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 6552        '''
 6553         The path used to check the health of your connection.  Defaults to `default`.
 6554        '''
 6555        self.healthy = healthy if healthy is not None else False
 6556        '''
 6557         True if the datasource is reachable and the credentials are valid.
 6558        '''
 6559        self.hostname = hostname if hostname is not None else ''
 6560        '''
 6561
 6562        '''
 6563        self.id = id if id is not None else ''
 6564        '''
 6565         Unique identifier of the Resource.
 6566        '''
 6567        self.name = name if name is not None else ''
 6568        '''
 6569         Unique human-readable name of the Resource.
 6570        '''
 6571        self.port = port if port is not None else 0
 6572        '''
 6573
 6574        '''
 6575        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
 6576        '''
 6577
 6578        '''
 6579        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
 6580        '''
 6581
 6582        '''
 6583        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 6584        '''
 6585         ID of the secret store containing credentials for this resource, if any.
 6586        '''
 6587        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 6588        '''
 6589         Tags is a map of key, value pairs.
 6590        '''
 6591        self.token = token if token is not None else ''
 6592        '''
 6593
 6594        '''
 6595
 6596    def __repr__(self):
 6597        return '<sdm.KubernetesServiceAccount ' + \
 6598            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 6599            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 6600            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 6601            'healthy: ' + repr(self.healthy) + ' ' +\
 6602            'hostname: ' + repr(self.hostname) + ' ' +\
 6603            'id: ' + repr(self.id) + ' ' +\
 6604            'name: ' + repr(self.name) + ' ' +\
 6605            'port: ' + repr(self.port) + ' ' +\
 6606            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
 6607            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
 6608            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 6609            'tags: ' + repr(self.tags) + ' ' +\
 6610            'token: ' + repr(self.token) + ' ' +\
 6611            '>'
 6612
 6613    def to_dict(self):
 6614        return {
 6615            'bind_interface': self.bind_interface,
 6616            'egress_filter': self.egress_filter,
 6617            'healthcheck_namespace': self.healthcheck_namespace,
 6618            'healthy': self.healthy,
 6619            'hostname': self.hostname,
 6620            'id': self.id,
 6621            'name': self.name,
 6622            'port': self.port,
 6623            'remote_identity_group_id': self.remote_identity_group_id,
 6624            'remote_identity_healthcheck_username':
 6625            self.remote_identity_healthcheck_username,
 6626            'secret_store_id': self.secret_store_id,
 6627            'tags': self.tags,
 6628            'token': self.token,
 6629        }
 6630
 6631    @classmethod
 6632    def from_dict(cls, d):
 6633        return cls(
 6634            bind_interface=d.get('bind_interface'),
 6635            egress_filter=d.get('egress_filter'),
 6636            healthcheck_namespace=d.get('healthcheck_namespace'),
 6637            healthy=d.get('healthy'),
 6638            hostname=d.get('hostname'),
 6639            id=d.get('id'),
 6640            name=d.get('name'),
 6641            port=d.get('port'),
 6642            remote_identity_group_id=d.get('remote_identity_group_id'),
 6643            remote_identity_healthcheck_username=d.get(
 6644                'remote_identity_healthcheck_username'),
 6645            secret_store_id=d.get('secret_store_id'),
 6646            tags=d.get('tags'),
 6647            token=d.get('token'),
 6648        )
 6649
 6650
 6651class KubernetesServiceAccountUserImpersonation:
 6652    '''
 6653
 6654    '''
 6655    __slots__ = [
 6656        'bind_interface',
 6657        'egress_filter',
 6658        'healthcheck_namespace',
 6659        'healthy',
 6660        'hostname',
 6661        'id',
 6662        'name',
 6663        'port',
 6664        'secret_store_id',
 6665        'tags',
 6666        'token',
 6667    ]
 6668
 6669    def __init__(
 6670        self,
 6671        bind_interface=None,
 6672        egress_filter=None,
 6673        healthcheck_namespace=None,
 6674        healthy=None,
 6675        hostname=None,
 6676        id=None,
 6677        name=None,
 6678        port=None,
 6679        secret_store_id=None,
 6680        tags=None,
 6681        token=None,
 6682    ):
 6683        self.bind_interface = bind_interface if bind_interface is not None else ''
 6684        '''
 6685         Bind interface
 6686        '''
 6687        self.egress_filter = egress_filter if egress_filter is not None else ''
 6688        '''
 6689         A filter applied to the routing logic to pin datasource to nodes.
 6690        '''
 6691        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 6692        '''
 6693         The path used to check the health of your connection.  Defaults to `default`.
 6694        '''
 6695        self.healthy = healthy if healthy is not None else False
 6696        '''
 6697         True if the datasource is reachable and the credentials are valid.
 6698        '''
 6699        self.hostname = hostname if hostname is not None else ''
 6700        '''
 6701
 6702        '''
 6703        self.id = id if id is not None else ''
 6704        '''
 6705         Unique identifier of the Resource.
 6706        '''
 6707        self.name = name if name is not None else ''
 6708        '''
 6709         Unique human-readable name of the Resource.
 6710        '''
 6711        self.port = port if port is not None else 0
 6712        '''
 6713
 6714        '''
 6715        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 6716        '''
 6717         ID of the secret store containing credentials for this resource, if any.
 6718        '''
 6719        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 6720        '''
 6721         Tags is a map of key, value pairs.
 6722        '''
 6723        self.token = token if token is not None else ''
 6724        '''
 6725
 6726        '''
 6727
 6728    def __repr__(self):
 6729        return '<sdm.KubernetesServiceAccountUserImpersonation ' + \
 6730            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 6731            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 6732            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 6733            'healthy: ' + repr(self.healthy) + ' ' +\
 6734            'hostname: ' + repr(self.hostname) + ' ' +\
 6735            'id: ' + repr(self.id) + ' ' +\
 6736            'name: ' + repr(self.name) + ' ' +\
 6737            'port: ' + repr(self.port) + ' ' +\
 6738            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 6739            'tags: ' + repr(self.tags) + ' ' +\
 6740            'token: ' + repr(self.token) + ' ' +\
 6741            '>'
 6742
 6743    def to_dict(self):
 6744        return {
 6745            'bind_interface': self.bind_interface,
 6746            'egress_filter': self.egress_filter,
 6747            'healthcheck_namespace': self.healthcheck_namespace,
 6748            'healthy': self.healthy,
 6749            'hostname': self.hostname,
 6750            'id': self.id,
 6751            'name': self.name,
 6752            'port': self.port,
 6753            'secret_store_id': self.secret_store_id,
 6754            'tags': self.tags,
 6755            'token': self.token,
 6756        }
 6757
 6758    @classmethod
 6759    def from_dict(cls, d):
 6760        return cls(
 6761            bind_interface=d.get('bind_interface'),
 6762            egress_filter=d.get('egress_filter'),
 6763            healthcheck_namespace=d.get('healthcheck_namespace'),
 6764            healthy=d.get('healthy'),
 6765            hostname=d.get('hostname'),
 6766            id=d.get('id'),
 6767            name=d.get('name'),
 6768            port=d.get('port'),
 6769            secret_store_id=d.get('secret_store_id'),
 6770            tags=d.get('tags'),
 6771            token=d.get('token'),
 6772        )
 6773
 6774
 6775class KubernetesUserImpersonation:
 6776    '''
 6777
 6778    '''
 6779    __slots__ = [
 6780        'bind_interface',
 6781        'certificate_authority',
 6782        'client_certificate',
 6783        'client_key',
 6784        'egress_filter',
 6785        'healthcheck_namespace',
 6786        'healthy',
 6787        'hostname',
 6788        'id',
 6789        'name',
 6790        'port',
 6791        'secret_store_id',
 6792        'tags',
 6793    ]
 6794
 6795    def __init__(
 6796        self,
 6797        bind_interface=None,
 6798        certificate_authority=None,
 6799        client_certificate=None,
 6800        client_key=None,
 6801        egress_filter=None,
 6802        healthcheck_namespace=None,
 6803        healthy=None,
 6804        hostname=None,
 6805        id=None,
 6806        name=None,
 6807        port=None,
 6808        secret_store_id=None,
 6809        tags=None,
 6810    ):
 6811        self.bind_interface = bind_interface if bind_interface is not None else ''
 6812        '''
 6813         Bind interface
 6814        '''
 6815        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 6816        '''
 6817
 6818        '''
 6819        self.client_certificate = client_certificate if client_certificate is not None else ''
 6820        '''
 6821
 6822        '''
 6823        self.client_key = client_key if client_key is not None else ''
 6824        '''
 6825
 6826        '''
 6827        self.egress_filter = egress_filter if egress_filter is not None else ''
 6828        '''
 6829         A filter applied to the routing logic to pin datasource to nodes.
 6830        '''
 6831        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 6832        '''
 6833         The path used to check the health of your connection.  Defaults to `default`.
 6834        '''
 6835        self.healthy = healthy if healthy is not None else False
 6836        '''
 6837         True if the datasource is reachable and the credentials are valid.
 6838        '''
 6839        self.hostname = hostname if hostname is not None else ''
 6840        '''
 6841
 6842        '''
 6843        self.id = id if id is not None else ''
 6844        '''
 6845         Unique identifier of the Resource.
 6846        '''
 6847        self.name = name if name is not None else ''
 6848        '''
 6849         Unique human-readable name of the Resource.
 6850        '''
 6851        self.port = port if port is not None else 0
 6852        '''
 6853
 6854        '''
 6855        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 6856        '''
 6857         ID of the secret store containing credentials for this resource, if any.
 6858        '''
 6859        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 6860        '''
 6861         Tags is a map of key, value pairs.
 6862        '''
 6863
 6864    def __repr__(self):
 6865        return '<sdm.KubernetesUserImpersonation ' + \
 6866            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 6867            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
 6868            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
 6869            'client_key: ' + repr(self.client_key) + ' ' +\
 6870            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 6871            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
 6872            'healthy: ' + repr(self.healthy) + ' ' +\
 6873            'hostname: ' + repr(self.hostname) + ' ' +\
 6874            'id: ' + repr(self.id) + ' ' +\
 6875            'name: ' + repr(self.name) + ' ' +\
 6876            'port: ' + repr(self.port) + ' ' +\
 6877            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 6878            'tags: ' + repr(self.tags) + ' ' +\
 6879            '>'
 6880
 6881    def to_dict(self):
 6882        return {
 6883            'bind_interface': self.bind_interface,
 6884            'certificate_authority': self.certificate_authority,
 6885            'client_certificate': self.client_certificate,
 6886            'client_key': self.client_key,
 6887            'egress_filter': self.egress_filter,
 6888            'healthcheck_namespace': self.healthcheck_namespace,
 6889            'healthy': self.healthy,
 6890            'hostname': self.hostname,
 6891            'id': self.id,
 6892            'name': self.name,
 6893            'port': self.port,
 6894            'secret_store_id': self.secret_store_id,
 6895            'tags': self.tags,
 6896        }
 6897
 6898    @classmethod
 6899    def from_dict(cls, d):
 6900        return cls(
 6901            bind_interface=d.get('bind_interface'),
 6902            certificate_authority=d.get('certificate_authority'),
 6903            client_certificate=d.get('client_certificate'),
 6904            client_key=d.get('client_key'),
 6905            egress_filter=d.get('egress_filter'),
 6906            healthcheck_namespace=d.get('healthcheck_namespace'),
 6907            healthy=d.get('healthy'),
 6908            hostname=d.get('hostname'),
 6909            id=d.get('id'),
 6910            name=d.get('name'),
 6911            port=d.get('port'),
 6912            secret_store_id=d.get('secret_store_id'),
 6913            tags=d.get('tags'),
 6914        )
 6915
 6916
 6917class MTLSMysql:
 6918    '''
 6919
 6920    '''
 6921    __slots__ = [
 6922        'bind_interface',
 6923        'certificate_authority',
 6924        'client_certificate',
 6925        'client_key',
 6926        'database',
 6927        'egress_filter',
 6928        'healthy',
 6929        'hostname',
 6930        'id',
 6931        'name',
 6932        'password',
 6933        'port',
 6934        'port_override',
 6935        'secret_store_id',
 6936        'server_name',
 6937        'tags',
 6938        'username',
 6939    ]
 6940
 6941    def __init__(
 6942        self,
 6943        bind_interface=None,
 6944        certificate_authority=None,
 6945        client_certificate=None,
 6946        client_key=None,
 6947        database=None,
 6948        egress_filter=None,
 6949        healthy=None,
 6950        hostname=None,
 6951        id=None,
 6952        name=None,
 6953        password=None,
 6954        port=None,
 6955        port_override=None,
 6956        secret_store_id=None,
 6957        server_name=None,
 6958        tags=None,
 6959        username=None,
 6960    ):
 6961        self.bind_interface = bind_interface if bind_interface is not None else ''
 6962        '''
 6963         Bind interface
 6964        '''
 6965        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 6966        '''
 6967
 6968        '''
 6969        self.client_certificate = client_certificate if client_certificate is not None else ''
 6970        '''
 6971
 6972        '''
 6973        self.client_key = client_key if client_key is not None else ''
 6974        '''
 6975
 6976        '''
 6977        self.database = database if database is not None else ''
 6978        '''
 6979
 6980        '''
 6981        self.egress_filter = egress_filter if egress_filter is not None else ''
 6982        '''
 6983         A filter applied to the routing logic to pin datasource to nodes.
 6984        '''
 6985        self.healthy = healthy if healthy is not None else False
 6986        '''
 6987         True if the datasource is reachable and the credentials are valid.
 6988        '''
 6989        self.hostname = hostname if hostname is not None else ''
 6990        '''
 6991
 6992        '''
 6993        self.id = id if id is not None else ''
 6994        '''
 6995         Unique identifier of the Resource.
 6996        '''
 6997        self.name = name if name is not None else ''
 6998        '''
 6999         Unique human-readable name of the Resource.
 7000        '''
 7001        self.password = password if password is not None else ''
 7002        '''
 7003
 7004        '''
 7005        self.port = port if port is not None else 0
 7006        '''
 7007
 7008        '''
 7009        self.port_override = port_override if port_override is not None else 0
 7010        '''
 7011
 7012        '''
 7013        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 7014        '''
 7015         ID of the secret store containing credentials for this resource, if any.
 7016        '''
 7017        self.server_name = server_name if server_name is not None else ''
 7018        '''
 7019
 7020        '''
 7021        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 7022        '''
 7023         Tags is a map of key, value pairs.
 7024        '''
 7025        self.username = username if username is not None else ''
 7026        '''
 7027
 7028        '''
 7029
 7030    def __repr__(self):
 7031        return '<sdm.MTLSMysql ' + \
 7032            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 7033            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
 7034            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
 7035            'client_key: ' + repr(self.client_key) + ' ' +\
 7036            'database: ' + repr(self.database) + ' ' +\
 7037            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 7038            'healthy: ' + repr(self.healthy) + ' ' +\
 7039            'hostname: ' + repr(self.hostname) + ' ' +\
 7040            'id: ' + repr(self.id) + ' ' +\
 7041            'name: ' + repr(self.name) + ' ' +\
 7042            'password: ' + repr(self.password) + ' ' +\
 7043            'port: ' + repr(self.port) + ' ' +\
 7044            'port_override: ' + repr(self.port_override) + ' ' +\
 7045            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 7046            'server_name: ' + repr(self.server_name) + ' ' +\
 7047            'tags: ' + repr(self.tags) + ' ' +\
 7048            'username: ' + repr(self.username) + ' ' +\
 7049            '>'
 7050
 7051    def to_dict(self):
 7052        return {
 7053            'bind_interface': self.bind_interface,
 7054            'certificate_authority': self.certificate_authority,
 7055            'client_certificate': self.client_certificate,
 7056            'client_key': self.client_key,
 7057            'database': self.database,
 7058            'egress_filter': self.egress_filter,
 7059            'healthy': self.healthy,
 7060            'hostname': self.hostname,
 7061            'id': self.id,
 7062            'name': self.name,
 7063            'password': self.password,
 7064            'port': self.port,
 7065            'port_override': self.port_override,
 7066            'secret_store_id': self.secret_store_id,
 7067            'server_name': self.server_name,
 7068            'tags': self.tags,
 7069            'username': self.username,
 7070        }
 7071
 7072    @classmethod
 7073    def from_dict(cls, d):
 7074        return cls(
 7075            bind_interface=d.get('bind_interface'),
 7076            certificate_authority=d.get('certificate_authority'),
 7077            client_certificate=d.get('client_certificate'),
 7078            client_key=d.get('client_key'),
 7079            database=d.get('database'),
 7080            egress_filter=d.get('egress_filter'),
 7081            healthy=d.get('healthy'),
 7082            hostname=d.get('hostname'),
 7083            id=d.get('id'),
 7084            name=d.get('name'),
 7085            password=d.get('password'),
 7086            port=d.get('port'),
 7087            port_override=d.get('port_override'),
 7088            secret_store_id=d.get('secret_store_id'),
 7089            server_name=d.get('server_name'),
 7090            tags=d.get('tags'),
 7091            username=d.get('username'),
 7092        )
 7093
 7094
 7095class MTLSPostgres:
 7096    '''
 7097
 7098    '''
 7099    __slots__ = [
 7100        'bind_interface',
 7101        'certificate_authority',
 7102        'client_certificate',
 7103        'client_key',
 7104        'database',
 7105        'egress_filter',
 7106        'healthy',
 7107        'hostname',
 7108        'id',
 7109        'name',
 7110        'override_database',
 7111        'password',
 7112        'port',
 7113        'port_override',
 7114        'secret_store_id',
 7115        'server_name',
 7116        'tags',
 7117        'username',
 7118    ]
 7119
 7120    def __init__(
 7121        self,
 7122        bind_interface=None,
 7123        certificate_authority=None,
 7124        client_certificate=None,
 7125        client_key=None,
 7126        database=None,
 7127        egress_filter=None,
 7128        healthy=None,
 7129        hostname=None,
 7130        id=None,
 7131        name=None,
 7132        override_database=None,
 7133        password=None,
 7134        port=None,
 7135        port_override=None,
 7136        secret_store_id=None,
 7137        server_name=None,
 7138        tags=None,
 7139        username=None,
 7140    ):
 7141        self.bind_interface = bind_interface if bind_interface is not None else ''
 7142        '''
 7143         Bind interface
 7144        '''
 7145        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 7146        '''
 7147
 7148        '''
 7149        self.client_certificate = client_certificate if client_certificate is not None else ''
 7150        '''
 7151
 7152        '''
 7153        self.client_key = client_key if client_key is not None else ''
 7154        '''
 7155
 7156        '''
 7157        self.database = database if database is not None else ''
 7158        '''
 7159
 7160        '''
 7161        self.egress_filter = egress_filter if egress_filter is not None else ''
 7162        '''
 7163         A filter applied to the routing logic to pin datasource to nodes.
 7164        '''
 7165        self.healthy = healthy if healthy is not None else False
 7166        '''
 7167         True if the datasource is reachable and the credentials are valid.
 7168        '''
 7169        self.hostname = hostname if hostname is not None else ''
 7170        '''
 7171
 7172        '''
 7173        self.id = id if id is not None else ''
 7174        '''
 7175         Unique identifier of the Resource.
 7176        '''
 7177        self.name = name if name is not None else ''
 7178        '''
 7179         Unique human-readable name of the Resource.
 7180        '''
 7181        self.override_database = override_database if override_database is not None else False
 7182        '''
 7183
 7184        '''
 7185        self.password = password if password is not None else ''
 7186        '''
 7187
 7188        '''
 7189        self.port = port if port is not None else 0
 7190        '''
 7191
 7192        '''
 7193        self.port_override = port_override if port_override is not None else 0
 7194        '''
 7195
 7196        '''
 7197        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 7198        '''
 7199         ID of the secret store containing credentials for this resource, if any.
 7200        '''
 7201        self.server_name = server_name if server_name is not None else ''
 7202        '''
 7203
 7204        '''
 7205        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 7206        '''
 7207         Tags is a map of key, value pairs.
 7208        '''
 7209        self.username = username if username is not None else ''
 7210        '''
 7211
 7212        '''
 7213
 7214    def __repr__(self):
 7215        return '<sdm.MTLSPostgres ' + \
 7216            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 7217            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
 7218            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
 7219            'client_key: ' + repr(self.client_key) + ' ' +\
 7220            'database: ' + repr(self.database) + ' ' +\
 7221            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 7222            'healthy: ' + repr(self.healthy) + ' ' +\
 7223            'hostname: ' + repr(self.hostname) + ' ' +\
 7224            'id: ' + repr(self.id) + ' ' +\
 7225            'name: ' + repr(self.name) + ' ' +\
 7226            'override_database: ' + repr(self.override_database) + ' ' +\
 7227            'password: ' + repr(self.password) + ' ' +\
 7228            'port: ' + repr(self.port) + ' ' +\
 7229            'port_override: ' + repr(self.port_override) + ' ' +\
 7230            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 7231            'server_name: ' + repr(self.server_name) + ' ' +\
 7232            'tags: ' + repr(self.tags) + ' ' +\
 7233            'username: ' + repr(self.username) + ' ' +\
 7234            '>'
 7235
 7236    def to_dict(self):
 7237        return {
 7238            'bind_interface': self.bind_interface,
 7239            'certificate_authority': self.certificate_authority,
 7240            'client_certificate': self.client_certificate,
 7241            'client_key': self.client_key,
 7242            'database': self.database,
 7243            'egress_filter': self.egress_filter,
 7244            'healthy': self.healthy,
 7245            'hostname': self.hostname,
 7246            'id': self.id,
 7247            'name': self.name,
 7248            'override_database': self.override_database,
 7249            'password': self.password,
 7250            'port': self.port,
 7251            'port_override': self.port_override,
 7252            'secret_store_id': self.secret_store_id,
 7253            'server_name': self.server_name,
 7254            'tags': self.tags,
 7255            'username': self.username,
 7256        }
 7257
 7258    @classmethod
 7259    def from_dict(cls, d):
 7260        return cls(
 7261            bind_interface=d.get('bind_interface'),
 7262            certificate_authority=d.get('certificate_authority'),
 7263            client_certificate=d.get('client_certificate'),
 7264            client_key=d.get('client_key'),
 7265            database=d.get('database'),
 7266            egress_filter=d.get('egress_filter'),
 7267            healthy=d.get('healthy'),
 7268            hostname=d.get('hostname'),
 7269            id=d.get('id'),
 7270            name=d.get('name'),
 7271            override_database=d.get('override_database'),
 7272            password=d.get('password'),
 7273            port=d.get('port'),
 7274            port_override=d.get('port_override'),
 7275            secret_store_id=d.get('secret_store_id'),
 7276            server_name=d.get('server_name'),
 7277            tags=d.get('tags'),
 7278            username=d.get('username'),
 7279        )
 7280
 7281
 7282class Maria:
 7283    '''
 7284
 7285    '''
 7286    __slots__ = [
 7287        'bind_interface',
 7288        'database',
 7289        'egress_filter',
 7290        'healthy',
 7291        'hostname',
 7292        'id',
 7293        'name',
 7294        'password',
 7295        'port',
 7296        'port_override',
 7297        'secret_store_id',
 7298        'tags',
 7299        'username',
 7300    ]
 7301
 7302    def __init__(
 7303        self,
 7304        bind_interface=None,
 7305        database=None,
 7306        egress_filter=None,
 7307        healthy=None,
 7308        hostname=None,
 7309        id=None,
 7310        name=None,
 7311        password=None,
 7312        port=None,
 7313        port_override=None,
 7314        secret_store_id=None,
 7315        tags=None,
 7316        username=None,
 7317    ):
 7318        self.bind_interface = bind_interface if bind_interface is not None else ''
 7319        '''
 7320         Bind interface
 7321        '''
 7322        self.database = database if database is not None else ''
 7323        '''
 7324
 7325        '''
 7326        self.egress_filter = egress_filter if egress_filter is not None else ''
 7327        '''
 7328         A filter applied to the routing logic to pin datasource to nodes.
 7329        '''
 7330        self.healthy = healthy if healthy is not None else False
 7331        '''
 7332         True if the datasource is reachable and the credentials are valid.
 7333        '''
 7334        self.hostname = hostname if hostname is not None else ''
 7335        '''
 7336
 7337        '''
 7338        self.id = id if id is not None else ''
 7339        '''
 7340         Unique identifier of the Resource.
 7341        '''
 7342        self.name = name if name is not None else ''
 7343        '''
 7344         Unique human-readable name of the Resource.
 7345        '''
 7346        self.password = password if password is not None else ''
 7347        '''
 7348
 7349        '''
 7350        self.port = port if port is not None else 0
 7351        '''
 7352
 7353        '''
 7354        self.port_override = port_override if port_override is not None else 0
 7355        '''
 7356
 7357        '''
 7358        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 7359        '''
 7360         ID of the secret store containing credentials for this resource, if any.
 7361        '''
 7362        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 7363        '''
 7364         Tags is a map of key, value pairs.
 7365        '''
 7366        self.username = username if username is not None else ''
 7367        '''
 7368
 7369        '''
 7370
 7371    def __repr__(self):
 7372        return '<sdm.Maria ' + \
 7373            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 7374            'database: ' + repr(self.database) + ' ' +\
 7375            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 7376            'healthy: ' + repr(self.healthy) + ' ' +\
 7377            'hostname: ' + repr(self.hostname) + ' ' +\
 7378            'id: ' + repr(self.id) + ' ' +\
 7379            'name: ' + repr(self.name) + ' ' +\
 7380            'password: ' + repr(self.password) + ' ' +\
 7381            'port: ' + repr(self.port) + ' ' +\
 7382            'port_override: ' + repr(self.port_override) + ' ' +\
 7383            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 7384            'tags: ' + repr(self.tags) + ' ' +\
 7385            'username: ' + repr(self.username) + ' ' +\
 7386            '>'
 7387
 7388    def to_dict(self):
 7389        return {
 7390            'bind_interface': self.bind_interface,
 7391            'database': self.database,
 7392            'egress_filter': self.egress_filter,
 7393            'healthy': self.healthy,
 7394            'hostname': self.hostname,
 7395            'id': self.id,
 7396            'name': self.name,
 7397            'password': self.password,
 7398            'port': self.port,
 7399            'port_override': self.port_override,
 7400            'secret_store_id': self.secret_store_id,
 7401            'tags': self.tags,
 7402            'username': self.username,
 7403        }
 7404
 7405    @classmethod
 7406    def from_dict(cls, d):
 7407        return cls(
 7408            bind_interface=d.get('bind_interface'),
 7409            database=d.get('database'),
 7410            egress_filter=d.get('egress_filter'),
 7411            healthy=d.get('healthy'),
 7412            hostname=d.get('hostname'),
 7413            id=d.get('id'),
 7414            name=d.get('name'),
 7415            password=d.get('password'),
 7416            port=d.get('port'),
 7417            port_override=d.get('port_override'),
 7418            secret_store_id=d.get('secret_store_id'),
 7419            tags=d.get('tags'),
 7420            username=d.get('username'),
 7421        )
 7422
 7423
 7424class Memcached:
 7425    '''
 7426
 7427    '''
 7428    __slots__ = [
 7429        'bind_interface',
 7430        'egress_filter',
 7431        'healthy',
 7432        'hostname',
 7433        'id',
 7434        'name',
 7435        'port',
 7436        'port_override',
 7437        'secret_store_id',
 7438        'tags',
 7439    ]
 7440
 7441    def __init__(
 7442        self,
 7443        bind_interface=None,
 7444        egress_filter=None,
 7445        healthy=None,
 7446        hostname=None,
 7447        id=None,
 7448        name=None,
 7449        port=None,
 7450        port_override=None,
 7451        secret_store_id=None,
 7452        tags=None,
 7453    ):
 7454        self.bind_interface = bind_interface if bind_interface is not None else ''
 7455        '''
 7456         Bind interface
 7457        '''
 7458        self.egress_filter = egress_filter if egress_filter is not None else ''
 7459        '''
 7460         A filter applied to the routing logic to pin datasource to nodes.
 7461        '''
 7462        self.healthy = healthy if healthy is not None else False
 7463        '''
 7464         True if the datasource is reachable and the credentials are valid.
 7465        '''
 7466        self.hostname = hostname if hostname is not None else ''
 7467        '''
 7468
 7469        '''
 7470        self.id = id if id is not None else ''
 7471        '''
 7472         Unique identifier of the Resource.
 7473        '''
 7474        self.name = name if name is not None else ''
 7475        '''
 7476         Unique human-readable name of the Resource.
 7477        '''
 7478        self.port = port if port is not None else 0
 7479        '''
 7480
 7481        '''
 7482        self.port_override = port_override if port_override is not None else 0
 7483        '''
 7484
 7485        '''
 7486        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 7487        '''
 7488         ID of the secret store containing credentials for this resource, if any.
 7489        '''
 7490        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 7491        '''
 7492         Tags is a map of key, value pairs.
 7493        '''
 7494
 7495    def __repr__(self):
 7496        return '<sdm.Memcached ' + \
 7497            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 7498            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 7499            'healthy: ' + repr(self.healthy) + ' ' +\
 7500            'hostname: ' + repr(self.hostname) + ' ' +\
 7501            'id: ' + repr(self.id) + ' ' +\
 7502            'name: ' + repr(self.name) + ' ' +\
 7503            'port: ' + repr(self.port) + ' ' +\
 7504            'port_override: ' + repr(self.port_override) + ' ' +\
 7505            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 7506            'tags: ' + repr(self.tags) + ' ' +\
 7507            '>'
 7508
 7509    def to_dict(self):
 7510        return {
 7511            'bind_interface': self.bind_interface,
 7512            'egress_filter': self.egress_filter,
 7513            'healthy': self.healthy,
 7514            'hostname': self.hostname,
 7515            'id': self.id,
 7516            'name': self.name,
 7517            'port': self.port,
 7518            'port_override': self.port_override,
 7519            'secret_store_id': self.secret_store_id,
 7520            'tags': self.tags,
 7521        }
 7522
 7523    @classmethod
 7524    def from_dict(cls, d):
 7525        return cls(
 7526            bind_interface=d.get('bind_interface'),
 7527            egress_filter=d.get('egress_filter'),
 7528            healthy=d.get('healthy'),
 7529            hostname=d.get('hostname'),
 7530            id=d.get('id'),
 7531            name=d.get('name'),
 7532            port=d.get('port'),
 7533            port_override=d.get('port_override'),
 7534            secret_store_id=d.get('secret_store_id'),
 7535            tags=d.get('tags'),
 7536        )
 7537
 7538
 7539class Memsql:
 7540    '''
 7541
 7542    '''
 7543    __slots__ = [
 7544        'bind_interface',
 7545        'database',
 7546        'egress_filter',
 7547        'healthy',
 7548        'hostname',
 7549        'id',
 7550        'name',
 7551        'password',
 7552        'port',
 7553        'port_override',
 7554        'secret_store_id',
 7555        'tags',
 7556        'username',
 7557    ]
 7558
 7559    def __init__(
 7560        self,
 7561        bind_interface=None,
 7562        database=None,
 7563        egress_filter=None,
 7564        healthy=None,
 7565        hostname=None,
 7566        id=None,
 7567        name=None,
 7568        password=None,
 7569        port=None,
 7570        port_override=None,
 7571        secret_store_id=None,
 7572        tags=None,
 7573        username=None,
 7574    ):
 7575        self.bind_interface = bind_interface if bind_interface is not None else ''
 7576        '''
 7577         Bind interface
 7578        '''
 7579        self.database = database if database is not None else ''
 7580        '''
 7581
 7582        '''
 7583        self.egress_filter = egress_filter if egress_filter is not None else ''
 7584        '''
 7585         A filter applied to the routing logic to pin datasource to nodes.
 7586        '''
 7587        self.healthy = healthy if healthy is not None else False
 7588        '''
 7589         True if the datasource is reachable and the credentials are valid.
 7590        '''
 7591        self.hostname = hostname if hostname is not None else ''
 7592        '''
 7593
 7594        '''
 7595        self.id = id if id is not None else ''
 7596        '''
 7597         Unique identifier of the Resource.
 7598        '''
 7599        self.name = name if name is not None else ''
 7600        '''
 7601         Unique human-readable name of the Resource.
 7602        '''
 7603        self.password = password if password is not None else ''
 7604        '''
 7605
 7606        '''
 7607        self.port = port if port is not None else 0
 7608        '''
 7609
 7610        '''
 7611        self.port_override = port_override if port_override is not None else 0
 7612        '''
 7613
 7614        '''
 7615        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 7616        '''
 7617         ID of the secret store containing credentials for this resource, if any.
 7618        '''
 7619        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 7620        '''
 7621         Tags is a map of key, value pairs.
 7622        '''
 7623        self.username = username if username is not None else ''
 7624        '''
 7625
 7626        '''
 7627
 7628    def __repr__(self):
 7629        return '<sdm.Memsql ' + \
 7630            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 7631            'database: ' + repr(self.database) + ' ' +\
 7632            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 7633            'healthy: ' + repr(self.healthy) + ' ' +\
 7634            'hostname: ' + repr(self.hostname) + ' ' +\
 7635            'id: ' + repr(self.id) + ' ' +\
 7636            'name: ' + repr(self.name) + ' ' +\
 7637            'password: ' + repr(self.password) + ' ' +\
 7638            'port: ' + repr(self.port) + ' ' +\
 7639            'port_override: ' + repr(self.port_override) + ' ' +\
 7640            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 7641            'tags: ' + repr(self.tags) + ' ' +\
 7642            'username: ' + repr(self.username) + ' ' +\
 7643            '>'
 7644
 7645    def to_dict(self):
 7646        return {
 7647            'bind_interface': self.bind_interface,
 7648            'database': self.database,
 7649            'egress_filter': self.egress_filter,
 7650            'healthy': self.healthy,
 7651            'hostname': self.hostname,
 7652            'id': self.id,
 7653            'name': self.name,
 7654            'password': self.password,
 7655            'port': self.port,
 7656            'port_override': self.port_override,
 7657            'secret_store_id': self.secret_store_id,
 7658            'tags': self.tags,
 7659            'username': self.username,
 7660        }
 7661
 7662    @classmethod
 7663    def from_dict(cls, d):
 7664        return cls(
 7665            bind_interface=d.get('bind_interface'),
 7666            database=d.get('database'),
 7667            egress_filter=d.get('egress_filter'),
 7668            healthy=d.get('healthy'),
 7669            hostname=d.get('hostname'),
 7670            id=d.get('id'),
 7671            name=d.get('name'),
 7672            password=d.get('password'),
 7673            port=d.get('port'),
 7674            port_override=d.get('port_override'),
 7675            secret_store_id=d.get('secret_store_id'),
 7676            tags=d.get('tags'),
 7677            username=d.get('username'),
 7678        )
 7679
 7680
 7681class MongoHost:
 7682    '''
 7683
 7684    '''
 7685    __slots__ = [
 7686        'auth_database',
 7687        'bind_interface',
 7688        'egress_filter',
 7689        'healthy',
 7690        'hostname',
 7691        'id',
 7692        'name',
 7693        'password',
 7694        'port',
 7695        'port_override',
 7696        'secret_store_id',
 7697        'tags',
 7698        'tls_required',
 7699        'username',
 7700    ]
 7701
 7702    def __init__(
 7703        self,
 7704        auth_database=None,
 7705        bind_interface=None,
 7706        egress_filter=None,
 7707        healthy=None,
 7708        hostname=None,
 7709        id=None,
 7710        name=None,
 7711        password=None,
 7712        port=None,
 7713        port_override=None,
 7714        secret_store_id=None,
 7715        tags=None,
 7716        tls_required=None,
 7717        username=None,
 7718    ):
 7719        self.auth_database = auth_database if auth_database is not None else ''
 7720        '''
 7721
 7722        '''
 7723        self.bind_interface = bind_interface if bind_interface is not None else ''
 7724        '''
 7725         Bind interface
 7726        '''
 7727        self.egress_filter = egress_filter if egress_filter is not None else ''
 7728        '''
 7729         A filter applied to the routing logic to pin datasource to nodes.
 7730        '''
 7731        self.healthy = healthy if healthy is not None else False
 7732        '''
 7733         True if the datasource is reachable and the credentials are valid.
 7734        '''
 7735        self.hostname = hostname if hostname is not None else ''
 7736        '''
 7737
 7738        '''
 7739        self.id = id if id is not None else ''
 7740        '''
 7741         Unique identifier of the Resource.
 7742        '''
 7743        self.name = name if name is not None else ''
 7744        '''
 7745         Unique human-readable name of the Resource.
 7746        '''
 7747        self.password = password if password is not None else ''
 7748        '''
 7749
 7750        '''
 7751        self.port = port if port is not None else 0
 7752        '''
 7753
 7754        '''
 7755        self.port_override = port_override if port_override is not None else 0
 7756        '''
 7757
 7758        '''
 7759        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 7760        '''
 7761         ID of the secret store containing credentials for this resource, if any.
 7762        '''
 7763        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 7764        '''
 7765         Tags is a map of key, value pairs.
 7766        '''
 7767        self.tls_required = tls_required if tls_required is not None else False
 7768        '''
 7769
 7770        '''
 7771        self.username = username if username is not None else ''
 7772        '''
 7773
 7774        '''
 7775
 7776    def __repr__(self):
 7777        return '<sdm.MongoHost ' + \
 7778            'auth_database: ' + repr(self.auth_database) + ' ' +\
 7779            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 7780            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 7781            'healthy: ' + repr(self.healthy) + ' ' +\
 7782            'hostname: ' + repr(self.hostname) + ' ' +\
 7783            'id: ' + repr(self.id) + ' ' +\
 7784            'name: ' + repr(self.name) + ' ' +\
 7785            'password: ' + repr(self.password) + ' ' +\
 7786            'port: ' + repr(self.port) + ' ' +\
 7787            'port_override: ' + repr(self.port_override) + ' ' +\
 7788            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 7789            'tags: ' + repr(self.tags) + ' ' +\
 7790            'tls_required: ' + repr(self.tls_required) + ' ' +\
 7791            'username: ' + repr(self.username) + ' ' +\
 7792            '>'
 7793
 7794    def to_dict(self):
 7795        return {
 7796            'auth_database': self.auth_database,
 7797            'bind_interface': self.bind_interface,
 7798            'egress_filter': self.egress_filter,
 7799            'healthy': self.healthy,
 7800            'hostname': self.hostname,
 7801            'id': self.id,
 7802            'name': self.name,
 7803            'password': self.password,
 7804            'port': self.port,
 7805            'port_override': self.port_override,
 7806            'secret_store_id': self.secret_store_id,
 7807            'tags': self.tags,
 7808            'tls_required': self.tls_required,
 7809            'username': self.username,
 7810        }
 7811
 7812    @classmethod
 7813    def from_dict(cls, d):
 7814        return cls(
 7815            auth_database=d.get('auth_database'),
 7816            bind_interface=d.get('bind_interface'),
 7817            egress_filter=d.get('egress_filter'),
 7818            healthy=d.get('healthy'),
 7819            hostname=d.get('hostname'),
 7820            id=d.get('id'),
 7821            name=d.get('name'),
 7822            password=d.get('password'),
 7823            port=d.get('port'),
 7824            port_override=d.get('port_override'),
 7825            secret_store_id=d.get('secret_store_id'),
 7826            tags=d.get('tags'),
 7827            tls_required=d.get('tls_required'),
 7828            username=d.get('username'),
 7829        )
 7830
 7831
 7832class MongoLegacyHost:
 7833    '''
 7834
 7835    '''
 7836    __slots__ = [
 7837        'auth_database',
 7838        'bind_interface',
 7839        'egress_filter',
 7840        'healthy',
 7841        'hostname',
 7842        'id',
 7843        'name',
 7844        'password',
 7845        'port',
 7846        'port_override',
 7847        'replica_set',
 7848        'secret_store_id',
 7849        'tags',
 7850        'tls_required',
 7851        'username',
 7852    ]
 7853
 7854    def __init__(
 7855        self,
 7856        auth_database=None,
 7857        bind_interface=None,
 7858        egress_filter=None,
 7859        healthy=None,
 7860        hostname=None,
 7861        id=None,
 7862        name=None,
 7863        password=None,
 7864        port=None,
 7865        port_override=None,
 7866        replica_set=None,
 7867        secret_store_id=None,
 7868        tags=None,
 7869        tls_required=None,
 7870        username=None,
 7871    ):
 7872        self.auth_database = auth_database if auth_database is not None else ''
 7873        '''
 7874
 7875        '''
 7876        self.bind_interface = bind_interface if bind_interface is not None else ''
 7877        '''
 7878         Bind interface
 7879        '''
 7880        self.egress_filter = egress_filter if egress_filter is not None else ''
 7881        '''
 7882         A filter applied to the routing logic to pin datasource to nodes.
 7883        '''
 7884        self.healthy = healthy if healthy is not None else False
 7885        '''
 7886         True if the datasource is reachable and the credentials are valid.
 7887        '''
 7888        self.hostname = hostname if hostname is not None else ''
 7889        '''
 7890
 7891        '''
 7892        self.id = id if id is not None else ''
 7893        '''
 7894         Unique identifier of the Resource.
 7895        '''
 7896        self.name = name if name is not None else ''
 7897        '''
 7898         Unique human-readable name of the Resource.
 7899        '''
 7900        self.password = password if password is not None else ''
 7901        '''
 7902
 7903        '''
 7904        self.port = port if port is not None else 0
 7905        '''
 7906
 7907        '''
 7908        self.port_override = port_override if port_override is not None else 0
 7909        '''
 7910
 7911        '''
 7912        self.replica_set = replica_set if replica_set is not None else ''
 7913        '''
 7914
 7915        '''
 7916        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 7917        '''
 7918         ID of the secret store containing credentials for this resource, if any.
 7919        '''
 7920        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 7921        '''
 7922         Tags is a map of key, value pairs.
 7923        '''
 7924        self.tls_required = tls_required if tls_required is not None else False
 7925        '''
 7926
 7927        '''
 7928        self.username = username if username is not None else ''
 7929        '''
 7930
 7931        '''
 7932
 7933    def __repr__(self):
 7934        return '<sdm.MongoLegacyHost ' + \
 7935            'auth_database: ' + repr(self.auth_database) + ' ' +\
 7936            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 7937            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 7938            'healthy: ' + repr(self.healthy) + ' ' +\
 7939            'hostname: ' + repr(self.hostname) + ' ' +\
 7940            'id: ' + repr(self.id) + ' ' +\
 7941            'name: ' + repr(self.name) + ' ' +\
 7942            'password: ' + repr(self.password) + ' ' +\
 7943            'port: ' + repr(self.port) + ' ' +\
 7944            'port_override: ' + repr(self.port_override) + ' ' +\
 7945            'replica_set: ' + repr(self.replica_set) + ' ' +\
 7946            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 7947            'tags: ' + repr(self.tags) + ' ' +\
 7948            'tls_required: ' + repr(self.tls_required) + ' ' +\
 7949            'username: ' + repr(self.username) + ' ' +\
 7950            '>'
 7951
 7952    def to_dict(self):
 7953        return {
 7954            'auth_database': self.auth_database,
 7955            'bind_interface': self.bind_interface,
 7956            'egress_filter': self.egress_filter,
 7957            'healthy': self.healthy,
 7958            'hostname': self.hostname,
 7959            'id': self.id,
 7960            'name': self.name,
 7961            'password': self.password,
 7962            'port': self.port,
 7963            'port_override': self.port_override,
 7964            'replica_set': self.replica_set,
 7965            'secret_store_id': self.secret_store_id,
 7966            'tags': self.tags,
 7967            'tls_required': self.tls_required,
 7968            'username': self.username,
 7969        }
 7970
 7971    @classmethod
 7972    def from_dict(cls, d):
 7973        return cls(
 7974            auth_database=d.get('auth_database'),
 7975            bind_interface=d.get('bind_interface'),
 7976            egress_filter=d.get('egress_filter'),
 7977            healthy=d.get('healthy'),
 7978            hostname=d.get('hostname'),
 7979            id=d.get('id'),
 7980            name=d.get('name'),
 7981            password=d.get('password'),
 7982            port=d.get('port'),
 7983            port_override=d.get('port_override'),
 7984            replica_set=d.get('replica_set'),
 7985            secret_store_id=d.get('secret_store_id'),
 7986            tags=d.get('tags'),
 7987            tls_required=d.get('tls_required'),
 7988            username=d.get('username'),
 7989        )
 7990
 7991
 7992class MongoLegacyReplicaset:
 7993    '''
 7994
 7995    '''
 7996    __slots__ = [
 7997        'auth_database',
 7998        'bind_interface',
 7999        'connect_to_replica',
 8000        'egress_filter',
 8001        'healthy',
 8002        'hostname',
 8003        'id',
 8004        'name',
 8005        'password',
 8006        'port',
 8007        'port_override',
 8008        'replica_set',
 8009        'secret_store_id',
 8010        'tags',
 8011        'tls_required',
 8012        'username',
 8013    ]
 8014
 8015    def __init__(
 8016        self,
 8017        auth_database=None,
 8018        bind_interface=None,
 8019        connect_to_replica=None,
 8020        egress_filter=None,
 8021        healthy=None,
 8022        hostname=None,
 8023        id=None,
 8024        name=None,
 8025        password=None,
 8026        port=None,
 8027        port_override=None,
 8028        replica_set=None,
 8029        secret_store_id=None,
 8030        tags=None,
 8031        tls_required=None,
 8032        username=None,
 8033    ):
 8034        self.auth_database = auth_database if auth_database is not None else ''
 8035        '''
 8036
 8037        '''
 8038        self.bind_interface = bind_interface if bind_interface is not None else ''
 8039        '''
 8040         Bind interface
 8041        '''
 8042        self.connect_to_replica = connect_to_replica if connect_to_replica is not None else False
 8043        '''
 8044
 8045        '''
 8046        self.egress_filter = egress_filter if egress_filter is not None else ''
 8047        '''
 8048         A filter applied to the routing logic to pin datasource to nodes.
 8049        '''
 8050        self.healthy = healthy if healthy is not None else False
 8051        '''
 8052         True if the datasource is reachable and the credentials are valid.
 8053        '''
 8054        self.hostname = hostname if hostname is not None else ''
 8055        '''
 8056
 8057        '''
 8058        self.id = id if id is not None else ''
 8059        '''
 8060         Unique identifier of the Resource.
 8061        '''
 8062        self.name = name if name is not None else ''
 8063        '''
 8064         Unique human-readable name of the Resource.
 8065        '''
 8066        self.password = password if password is not None else ''
 8067        '''
 8068
 8069        '''
 8070        self.port = port if port is not None else 0
 8071        '''
 8072
 8073        '''
 8074        self.port_override = port_override if port_override is not None else 0
 8075        '''
 8076
 8077        '''
 8078        self.replica_set = replica_set if replica_set is not None else ''
 8079        '''
 8080
 8081        '''
 8082        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 8083        '''
 8084         ID of the secret store containing credentials for this resource, if any.
 8085        '''
 8086        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 8087        '''
 8088         Tags is a map of key, value pairs.
 8089        '''
 8090        self.tls_required = tls_required if tls_required is not None else False
 8091        '''
 8092
 8093        '''
 8094        self.username = username if username is not None else ''
 8095        '''
 8096
 8097        '''
 8098
 8099    def __repr__(self):
 8100        return '<sdm.MongoLegacyReplicaset ' + \
 8101            'auth_database: ' + repr(self.auth_database) + ' ' +\
 8102            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 8103            'connect_to_replica: ' + repr(self.connect_to_replica) + ' ' +\
 8104            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 8105            'healthy: ' + repr(self.healthy) + ' ' +\
 8106            'hostname: ' + repr(self.hostname) + ' ' +\
 8107            'id: ' + repr(self.id) + ' ' +\
 8108            'name: ' + repr(self.name) + ' ' +\
 8109            'password: ' + repr(self.password) + ' ' +\
 8110            'port: ' + repr(self.port) + ' ' +\
 8111            'port_override: ' + repr(self.port_override) + ' ' +\
 8112            'replica_set: ' + repr(self.replica_set) + ' ' +\
 8113            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 8114            'tags: ' + repr(self.tags) + ' ' +\
 8115            'tls_required: ' + repr(self.tls_required) + ' ' +\
 8116            'username: ' + repr(self.username) + ' ' +\
 8117            '>'
 8118
 8119    def to_dict(self):
 8120        return {
 8121            'auth_database': self.auth_database,
 8122            'bind_interface': self.bind_interface,
 8123            'connect_to_replica': self.connect_to_replica,
 8124            'egress_filter': self.egress_filter,
 8125            'healthy': self.healthy,
 8126            'hostname': self.hostname,
 8127            'id': self.id,
 8128            'name': self.name,
 8129            'password': self.password,
 8130            'port': self.port,
 8131            'port_override': self.port_override,
 8132            'replica_set': self.replica_set,
 8133            'secret_store_id': self.secret_store_id,
 8134            'tags': self.tags,
 8135            'tls_required': self.tls_required,
 8136            'username': self.username,
 8137        }
 8138
 8139    @classmethod
 8140    def from_dict(cls, d):
 8141        return cls(
 8142            auth_database=d.get('auth_database'),
 8143            bind_interface=d.get('bind_interface'),
 8144            connect_to_replica=d.get('connect_to_replica'),
 8145            egress_filter=d.get('egress_filter'),
 8146            healthy=d.get('healthy'),
 8147            hostname=d.get('hostname'),
 8148            id=d.get('id'),
 8149            name=d.get('name'),
 8150            password=d.get('password'),
 8151            port=d.get('port'),
 8152            port_override=d.get('port_override'),
 8153            replica_set=d.get('replica_set'),
 8154            secret_store_id=d.get('secret_store_id'),
 8155            tags=d.get('tags'),
 8156            tls_required=d.get('tls_required'),
 8157            username=d.get('username'),
 8158        )
 8159
 8160
 8161class MongoReplicaSet:
 8162    '''
 8163
 8164    '''
 8165    __slots__ = [
 8166        'auth_database',
 8167        'bind_interface',
 8168        'connect_to_replica',
 8169        'egress_filter',
 8170        'healthy',
 8171        'hostname',
 8172        'id',
 8173        'name',
 8174        'password',
 8175        'port',
 8176        'port_override',
 8177        'replica_set',
 8178        'secret_store_id',
 8179        'tags',
 8180        'tls_required',
 8181        'username',
 8182    ]
 8183
 8184    def __init__(
 8185        self,
 8186        auth_database=None,
 8187        bind_interface=None,
 8188        connect_to_replica=None,
 8189        egress_filter=None,
 8190        healthy=None,
 8191        hostname=None,
 8192        id=None,
 8193        name=None,
 8194        password=None,
 8195        port=None,
 8196        port_override=None,
 8197        replica_set=None,
 8198        secret_store_id=None,
 8199        tags=None,
 8200        tls_required=None,
 8201        username=None,
 8202    ):
 8203        self.auth_database = auth_database if auth_database is not None else ''
 8204        '''
 8205
 8206        '''
 8207        self.bind_interface = bind_interface if bind_interface is not None else ''
 8208        '''
 8209         Bind interface
 8210        '''
 8211        self.connect_to_replica = connect_to_replica if connect_to_replica is not None else False
 8212        '''
 8213
 8214        '''
 8215        self.egress_filter = egress_filter if egress_filter is not None else ''
 8216        '''
 8217         A filter applied to the routing logic to pin datasource to nodes.
 8218        '''
 8219        self.healthy = healthy if healthy is not None else False
 8220        '''
 8221         True if the datasource is reachable and the credentials are valid.
 8222        '''
 8223        self.hostname = hostname if hostname is not None else ''
 8224        '''
 8225
 8226        '''
 8227        self.id = id if id is not None else ''
 8228        '''
 8229         Unique identifier of the Resource.
 8230        '''
 8231        self.name = name if name is not None else ''
 8232        '''
 8233         Unique human-readable name of the Resource.
 8234        '''
 8235        self.password = password if password is not None else ''
 8236        '''
 8237
 8238        '''
 8239        self.port = port if port is not None else 0
 8240        '''
 8241
 8242        '''
 8243        self.port_override = port_override if port_override is not None else 0
 8244        '''
 8245
 8246        '''
 8247        self.replica_set = replica_set if replica_set is not None else ''
 8248        '''
 8249
 8250        '''
 8251        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 8252        '''
 8253         ID of the secret store containing credentials for this resource, if any.
 8254        '''
 8255        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 8256        '''
 8257         Tags is a map of key, value pairs.
 8258        '''
 8259        self.tls_required = tls_required if tls_required is not None else False
 8260        '''
 8261
 8262        '''
 8263        self.username = username if username is not None else ''
 8264        '''
 8265
 8266        '''
 8267
 8268    def __repr__(self):
 8269        return '<sdm.MongoReplicaSet ' + \
 8270            'auth_database: ' + repr(self.auth_database) + ' ' +\
 8271            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 8272            'connect_to_replica: ' + repr(self.connect_to_replica) + ' ' +\
 8273            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 8274            'healthy: ' + repr(self.healthy) + ' ' +\
 8275            'hostname: ' + repr(self.hostname) + ' ' +\
 8276            'id: ' + repr(self.id) + ' ' +\
 8277            'name: ' + repr(self.name) + ' ' +\
 8278            'password: ' + repr(self.password) + ' ' +\
 8279            'port: ' + repr(self.port) + ' ' +\
 8280            'port_override: ' + repr(self.port_override) + ' ' +\
 8281            'replica_set: ' + repr(self.replica_set) + ' ' +\
 8282            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 8283            'tags: ' + repr(self.tags) + ' ' +\
 8284            'tls_required: ' + repr(self.tls_required) + ' ' +\
 8285            'username: ' + repr(self.username) + ' ' +\
 8286            '>'
 8287
 8288    def to_dict(self):
 8289        return {
 8290            'auth_database': self.auth_database,
 8291            'bind_interface': self.bind_interface,
 8292            'connect_to_replica': self.connect_to_replica,
 8293            'egress_filter': self.egress_filter,
 8294            'healthy': self.healthy,
 8295            'hostname': self.hostname,
 8296            'id': self.id,
 8297            'name': self.name,
 8298            'password': self.password,
 8299            'port': self.port,
 8300            'port_override': self.port_override,
 8301            'replica_set': self.replica_set,
 8302            'secret_store_id': self.secret_store_id,
 8303            'tags': self.tags,
 8304            'tls_required': self.tls_required,
 8305            'username': self.username,
 8306        }
 8307
 8308    @classmethod
 8309    def from_dict(cls, d):
 8310        return cls(
 8311            auth_database=d.get('auth_database'),
 8312            bind_interface=d.get('bind_interface'),
 8313            connect_to_replica=d.get('connect_to_replica'),
 8314            egress_filter=d.get('egress_filter'),
 8315            healthy=d.get('healthy'),
 8316            hostname=d.get('hostname'),
 8317            id=d.get('id'),
 8318            name=d.get('name'),
 8319            password=d.get('password'),
 8320            port=d.get('port'),
 8321            port_override=d.get('port_override'),
 8322            replica_set=d.get('replica_set'),
 8323            secret_store_id=d.get('secret_store_id'),
 8324            tags=d.get('tags'),
 8325            tls_required=d.get('tls_required'),
 8326            username=d.get('username'),
 8327        )
 8328
 8329
 8330class MongoShardedCluster:
 8331    '''
 8332
 8333    '''
 8334    __slots__ = [
 8335        'auth_database',
 8336        'bind_interface',
 8337        'egress_filter',
 8338        'healthy',
 8339        'hostname',
 8340        'id',
 8341        'name',
 8342        'password',
 8343        'port_override',
 8344        'secret_store_id',
 8345        'tags',
 8346        'tls_required',
 8347        'username',
 8348    ]
 8349
 8350    def __init__(
 8351        self,
 8352        auth_database=None,
 8353        bind_interface=None,
 8354        egress_filter=None,
 8355        healthy=None,
 8356        hostname=None,
 8357        id=None,
 8358        name=None,
 8359        password=None,
 8360        port_override=None,
 8361        secret_store_id=None,
 8362        tags=None,
 8363        tls_required=None,
 8364        username=None,
 8365    ):
 8366        self.auth_database = auth_database if auth_database is not None else ''
 8367        '''
 8368
 8369        '''
 8370        self.bind_interface = bind_interface if bind_interface is not None else ''
 8371        '''
 8372         Bind interface
 8373        '''
 8374        self.egress_filter = egress_filter if egress_filter is not None else ''
 8375        '''
 8376         A filter applied to the routing logic to pin datasource to nodes.
 8377        '''
 8378        self.healthy = healthy if healthy is not None else False
 8379        '''
 8380         True if the datasource is reachable and the credentials are valid.
 8381        '''
 8382        self.hostname = hostname if hostname is not None else ''
 8383        '''
 8384
 8385        '''
 8386        self.id = id if id is not None else ''
 8387        '''
 8388         Unique identifier of the Resource.
 8389        '''
 8390        self.name = name if name is not None else ''
 8391        '''
 8392         Unique human-readable name of the Resource.
 8393        '''
 8394        self.password = password if password is not None else ''
 8395        '''
 8396
 8397        '''
 8398        self.port_override = port_override if port_override is not None else 0
 8399        '''
 8400
 8401        '''
 8402        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 8403        '''
 8404         ID of the secret store containing credentials for this resource, if any.
 8405        '''
 8406        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 8407        '''
 8408         Tags is a map of key, value pairs.
 8409        '''
 8410        self.tls_required = tls_required if tls_required is not None else False
 8411        '''
 8412
 8413        '''
 8414        self.username = username if username is not None else ''
 8415        '''
 8416
 8417        '''
 8418
 8419    def __repr__(self):
 8420        return '<sdm.MongoShardedCluster ' + \
 8421            'auth_database: ' + repr(self.auth_database) + ' ' +\
 8422            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 8423            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 8424            'healthy: ' + repr(self.healthy) + ' ' +\
 8425            'hostname: ' + repr(self.hostname) + ' ' +\
 8426            'id: ' + repr(self.id) + ' ' +\
 8427            'name: ' + repr(self.name) + ' ' +\
 8428            'password: ' + repr(self.password) + ' ' +\
 8429            'port_override: ' + repr(self.port_override) + ' ' +\
 8430            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 8431            'tags: ' + repr(self.tags) + ' ' +\
 8432            'tls_required: ' + repr(self.tls_required) + ' ' +\
 8433            'username: ' + repr(self.username) + ' ' +\
 8434            '>'
 8435
 8436    def to_dict(self):
 8437        return {
 8438            'auth_database': self.auth_database,
 8439            'bind_interface': self.bind_interface,
 8440            'egress_filter': self.egress_filter,
 8441            'healthy': self.healthy,
 8442            'hostname': self.hostname,
 8443            'id': self.id,
 8444            'name': self.name,
 8445            'password': self.password,
 8446            'port_override': self.port_override,
 8447            'secret_store_id': self.secret_store_id,
 8448            'tags': self.tags,
 8449            'tls_required': self.tls_required,
 8450            'username': self.username,
 8451        }
 8452
 8453    @classmethod
 8454    def from_dict(cls, d):
 8455        return cls(
 8456            auth_database=d.get('auth_database'),
 8457            bind_interface=d.get('bind_interface'),
 8458            egress_filter=d.get('egress_filter'),
 8459            healthy=d.get('healthy'),
 8460            hostname=d.get('hostname'),
 8461            id=d.get('id'),
 8462            name=d.get('name'),
 8463            password=d.get('password'),
 8464            port_override=d.get('port_override'),
 8465            secret_store_id=d.get('secret_store_id'),
 8466            tags=d.get('tags'),
 8467            tls_required=d.get('tls_required'),
 8468            username=d.get('username'),
 8469        )
 8470
 8471
 8472class Mysql:
 8473    '''
 8474
 8475    '''
 8476    __slots__ = [
 8477        'bind_interface',
 8478        'database',
 8479        'egress_filter',
 8480        'healthy',
 8481        'hostname',
 8482        'id',
 8483        'name',
 8484        'password',
 8485        'port',
 8486        'port_override',
 8487        'secret_store_id',
 8488        'tags',
 8489        'username',
 8490    ]
 8491
 8492    def __init__(
 8493        self,
 8494        bind_interface=None,
 8495        database=None,
 8496        egress_filter=None,
 8497        healthy=None,
 8498        hostname=None,
 8499        id=None,
 8500        name=None,
 8501        password=None,
 8502        port=None,
 8503        port_override=None,
 8504        secret_store_id=None,
 8505        tags=None,
 8506        username=None,
 8507    ):
 8508        self.bind_interface = bind_interface if bind_interface is not None else ''
 8509        '''
 8510         Bind interface
 8511        '''
 8512        self.database = database if database is not None else ''
 8513        '''
 8514
 8515        '''
 8516        self.egress_filter = egress_filter if egress_filter is not None else ''
 8517        '''
 8518         A filter applied to the routing logic to pin datasource to nodes.
 8519        '''
 8520        self.healthy = healthy if healthy is not None else False
 8521        '''
 8522         True if the datasource is reachable and the credentials are valid.
 8523        '''
 8524        self.hostname = hostname if hostname is not None else ''
 8525        '''
 8526
 8527        '''
 8528        self.id = id if id is not None else ''
 8529        '''
 8530         Unique identifier of the Resource.
 8531        '''
 8532        self.name = name if name is not None else ''
 8533        '''
 8534         Unique human-readable name of the Resource.
 8535        '''
 8536        self.password = password if password is not None else ''
 8537        '''
 8538
 8539        '''
 8540        self.port = port if port is not None else 0
 8541        '''
 8542
 8543        '''
 8544        self.port_override = port_override if port_override is not None else 0
 8545        '''
 8546
 8547        '''
 8548        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 8549        '''
 8550         ID of the secret store containing credentials for this resource, if any.
 8551        '''
 8552        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 8553        '''
 8554         Tags is a map of key, value pairs.
 8555        '''
 8556        self.username = username if username is not None else ''
 8557        '''
 8558
 8559        '''
 8560
 8561    def __repr__(self):
 8562        return '<sdm.Mysql ' + \
 8563            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 8564            'database: ' + repr(self.database) + ' ' +\
 8565            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 8566            'healthy: ' + repr(self.healthy) + ' ' +\
 8567            'hostname: ' + repr(self.hostname) + ' ' +\
 8568            'id: ' + repr(self.id) + ' ' +\
 8569            'name: ' + repr(self.name) + ' ' +\
 8570            'password: ' + repr(self.password) + ' ' +\
 8571            'port: ' + repr(self.port) + ' ' +\
 8572            'port_override: ' + repr(self.port_override) + ' ' +\
 8573            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 8574            'tags: ' + repr(self.tags) + ' ' +\
 8575            'username: ' + repr(self.username) + ' ' +\
 8576            '>'
 8577
 8578    def to_dict(self):
 8579        return {
 8580            'bind_interface': self.bind_interface,
 8581            'database': self.database,
 8582            'egress_filter': self.egress_filter,
 8583            'healthy': self.healthy,
 8584            'hostname': self.hostname,
 8585            'id': self.id,
 8586            'name': self.name,
 8587            'password': self.password,
 8588            'port': self.port,
 8589            'port_override': self.port_override,
 8590            'secret_store_id': self.secret_store_id,
 8591            'tags': self.tags,
 8592            'username': self.username,
 8593        }
 8594
 8595    @classmethod
 8596    def from_dict(cls, d):
 8597        return cls(
 8598            bind_interface=d.get('bind_interface'),
 8599            database=d.get('database'),
 8600            egress_filter=d.get('egress_filter'),
 8601            healthy=d.get('healthy'),
 8602            hostname=d.get('hostname'),
 8603            id=d.get('id'),
 8604            name=d.get('name'),
 8605            password=d.get('password'),
 8606            port=d.get('port'),
 8607            port_override=d.get('port_override'),
 8608            secret_store_id=d.get('secret_store_id'),
 8609            tags=d.get('tags'),
 8610            username=d.get('username'),
 8611        )
 8612
 8613
 8614class Neptune:
 8615    '''
 8616
 8617    '''
 8618    __slots__ = [
 8619        'bind_interface',
 8620        'egress_filter',
 8621        'endpoint',
 8622        'healthy',
 8623        'id',
 8624        'name',
 8625        'port',
 8626        'port_override',
 8627        'secret_store_id',
 8628        'tags',
 8629    ]
 8630
 8631    def __init__(
 8632        self,
 8633        bind_interface=None,
 8634        egress_filter=None,
 8635        endpoint=None,
 8636        healthy=None,
 8637        id=None,
 8638        name=None,
 8639        port=None,
 8640        port_override=None,
 8641        secret_store_id=None,
 8642        tags=None,
 8643    ):
 8644        self.bind_interface = bind_interface if bind_interface is not None else ''
 8645        '''
 8646         Bind interface
 8647        '''
 8648        self.egress_filter = egress_filter if egress_filter is not None else ''
 8649        '''
 8650         A filter applied to the routing logic to pin datasource to nodes.
 8651        '''
 8652        self.endpoint = endpoint if endpoint is not None else ''
 8653        '''
 8654
 8655        '''
 8656        self.healthy = healthy if healthy is not None else False
 8657        '''
 8658         True if the datasource is reachable and the credentials are valid.
 8659        '''
 8660        self.id = id if id is not None else ''
 8661        '''
 8662         Unique identifier of the Resource.
 8663        '''
 8664        self.name = name if name is not None else ''
 8665        '''
 8666         Unique human-readable name of the Resource.
 8667        '''
 8668        self.port = port if port is not None else 0
 8669        '''
 8670
 8671        '''
 8672        self.port_override = port_override if port_override is not None else 0
 8673        '''
 8674
 8675        '''
 8676        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 8677        '''
 8678         ID of the secret store containing credentials for this resource, if any.
 8679        '''
 8680        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 8681        '''
 8682         Tags is a map of key, value pairs.
 8683        '''
 8684
 8685    def __repr__(self):
 8686        return '<sdm.Neptune ' + \
 8687            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 8688            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 8689            'endpoint: ' + repr(self.endpoint) + ' ' +\
 8690            'healthy: ' + repr(self.healthy) + ' ' +\
 8691            'id: ' + repr(self.id) + ' ' +\
 8692            'name: ' + repr(self.name) + ' ' +\
 8693            'port: ' + repr(self.port) + ' ' +\
 8694            'port_override: ' + repr(self.port_override) + ' ' +\
 8695            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 8696            'tags: ' + repr(self.tags) + ' ' +\
 8697            '>'
 8698
 8699    def to_dict(self):
 8700        return {
 8701            'bind_interface': self.bind_interface,
 8702            'egress_filter': self.egress_filter,
 8703            'endpoint': self.endpoint,
 8704            'healthy': self.healthy,
 8705            'id': self.id,
 8706            'name': self.name,
 8707            'port': self.port,
 8708            'port_override': self.port_override,
 8709            'secret_store_id': self.secret_store_id,
 8710            'tags': self.tags,
 8711        }
 8712
 8713    @classmethod
 8714    def from_dict(cls, d):
 8715        return cls(
 8716            bind_interface=d.get('bind_interface'),
 8717            egress_filter=d.get('egress_filter'),
 8718            endpoint=d.get('endpoint'),
 8719            healthy=d.get('healthy'),
 8720            id=d.get('id'),
 8721            name=d.get('name'),
 8722            port=d.get('port'),
 8723            port_override=d.get('port_override'),
 8724            secret_store_id=d.get('secret_store_id'),
 8725            tags=d.get('tags'),
 8726        )
 8727
 8728
 8729class NeptuneIAM:
 8730    '''
 8731
 8732    '''
 8733    __slots__ = [
 8734        'access_key',
 8735        'bind_interface',
 8736        'egress_filter',
 8737        'endpoint',
 8738        'healthy',
 8739        'id',
 8740        'name',
 8741        'port',
 8742        'port_override',
 8743        'region',
 8744        'role_arn',
 8745        'role_external_id',
 8746        'secret_access_key',
 8747        'secret_store_id',
 8748        'tags',
 8749    ]
 8750
 8751    def __init__(
 8752        self,
 8753        access_key=None,
 8754        bind_interface=None,
 8755        egress_filter=None,
 8756        endpoint=None,
 8757        healthy=None,
 8758        id=None,
 8759        name=None,
 8760        port=None,
 8761        port_override=None,
 8762        region=None,
 8763        role_arn=None,
 8764        role_external_id=None,
 8765        secret_access_key=None,
 8766        secret_store_id=None,
 8767        tags=None,
 8768    ):
 8769        self.access_key = access_key if access_key is not None else ''
 8770        '''
 8771
 8772        '''
 8773        self.bind_interface = bind_interface if bind_interface is not None else ''
 8774        '''
 8775         Bind interface
 8776        '''
 8777        self.egress_filter = egress_filter if egress_filter is not None else ''
 8778        '''
 8779         A filter applied to the routing logic to pin datasource to nodes.
 8780        '''
 8781        self.endpoint = endpoint if endpoint is not None else ''
 8782        '''
 8783
 8784        '''
 8785        self.healthy = healthy if healthy is not None else False
 8786        '''
 8787         True if the datasource is reachable and the credentials are valid.
 8788        '''
 8789        self.id = id if id is not None else ''
 8790        '''
 8791         Unique identifier of the Resource.
 8792        '''
 8793        self.name = name if name is not None else ''
 8794        '''
 8795         Unique human-readable name of the Resource.
 8796        '''
 8797        self.port = port if port is not None else 0
 8798        '''
 8799
 8800        '''
 8801        self.port_override = port_override if port_override is not None else 0
 8802        '''
 8803
 8804        '''
 8805        self.region = region if region is not None else ''
 8806        '''
 8807
 8808        '''
 8809        self.role_arn = role_arn if role_arn is not None else ''
 8810        '''
 8811
 8812        '''
 8813        self.role_external_id = role_external_id if role_external_id is not None else ''
 8814        '''
 8815
 8816        '''
 8817        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
 8818        '''
 8819
 8820        '''
 8821        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 8822        '''
 8823         ID of the secret store containing credentials for this resource, if any.
 8824        '''
 8825        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 8826        '''
 8827         Tags is a map of key, value pairs.
 8828        '''
 8829
 8830    def __repr__(self):
 8831        return '<sdm.NeptuneIAM ' + \
 8832            'access_key: ' + repr(self.access_key) + ' ' +\
 8833            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 8834            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 8835            'endpoint: ' + repr(self.endpoint) + ' ' +\
 8836            'healthy: ' + repr(self.healthy) + ' ' +\
 8837            'id: ' + repr(self.id) + ' ' +\
 8838            'name: ' + repr(self.name) + ' ' +\
 8839            'port: ' + repr(self.port) + ' ' +\
 8840            'port_override: ' + repr(self.port_override) + ' ' +\
 8841            'region: ' + repr(self.region) + ' ' +\
 8842            'role_arn: ' + repr(self.role_arn) + ' ' +\
 8843            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
 8844            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
 8845            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 8846            'tags: ' + repr(self.tags) + ' ' +\
 8847            '>'
 8848
 8849    def to_dict(self):
 8850        return {
 8851            'access_key': self.access_key,
 8852            'bind_interface': self.bind_interface,
 8853            'egress_filter': self.egress_filter,
 8854            'endpoint': self.endpoint,
 8855            'healthy': self.healthy,
 8856            'id': self.id,
 8857            'name': self.name,
 8858            'port': self.port,
 8859            'port_override': self.port_override,
 8860            'region': self.region,
 8861            'role_arn': self.role_arn,
 8862            'role_external_id': self.role_external_id,
 8863            'secret_access_key': self.secret_access_key,
 8864            'secret_store_id': self.secret_store_id,
 8865            'tags': self.tags,
 8866        }
 8867
 8868    @classmethod
 8869    def from_dict(cls, d):
 8870        return cls(
 8871            access_key=d.get('access_key'),
 8872            bind_interface=d.get('bind_interface'),
 8873            egress_filter=d.get('egress_filter'),
 8874            endpoint=d.get('endpoint'),
 8875            healthy=d.get('healthy'),
 8876            id=d.get('id'),
 8877            name=d.get('name'),
 8878            port=d.get('port'),
 8879            port_override=d.get('port_override'),
 8880            region=d.get('region'),
 8881            role_arn=d.get('role_arn'),
 8882            role_external_id=d.get('role_external_id'),
 8883            secret_access_key=d.get('secret_access_key'),
 8884            secret_store_id=d.get('secret_store_id'),
 8885            tags=d.get('tags'),
 8886        )
 8887
 8888
 8889class NodeCreateResponse:
 8890    '''
 8891     NodeCreateResponse reports how the Nodes were created in the system.
 8892    '''
 8893    __slots__ = [
 8894        'meta',
 8895        'node',
 8896        'rate_limit',
 8897        'token',
 8898    ]
 8899
 8900    def __init__(
 8901        self,
 8902        meta=None,
 8903        node=None,
 8904        rate_limit=None,
 8905        token=None,
 8906    ):
 8907        self.meta = meta if meta is not None else None
 8908        '''
 8909         Reserved for future use.
 8910        '''
 8911        self.node = node if node is not None else None
 8912        '''
 8913         The created Node.
 8914        '''
 8915        self.rate_limit = rate_limit if rate_limit is not None else None
 8916        '''
 8917         Rate limit information.
 8918        '''
 8919        self.token = token if token is not None else ''
 8920        '''
 8921         The auth token generated for the Node. The Node will use this token to
 8922         authenticate with the strongDM API.
 8923        '''
 8924
 8925    def __repr__(self):
 8926        return '<sdm.NodeCreateResponse ' + \
 8927            'meta: ' + repr(self.meta) + ' ' +\
 8928            'node: ' + repr(self.node) + ' ' +\
 8929            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 8930            'token: ' + repr(self.token) + ' ' +\
 8931            '>'
 8932
 8933    def to_dict(self):
 8934        return {
 8935            'meta': self.meta,
 8936            'node': self.node,
 8937            'rate_limit': self.rate_limit,
 8938            'token': self.token,
 8939        }
 8940
 8941    @classmethod
 8942    def from_dict(cls, d):
 8943        return cls(
 8944            meta=d.get('meta'),
 8945            node=d.get('node'),
 8946            rate_limit=d.get('rate_limit'),
 8947            token=d.get('token'),
 8948        )
 8949
 8950
 8951class NodeDeleteResponse:
 8952    '''
 8953     NodeDeleteResponse returns information about a Node that was deleted.
 8954    '''
 8955    __slots__ = [
 8956        'meta',
 8957        'rate_limit',
 8958    ]
 8959
 8960    def __init__(
 8961        self,
 8962        meta=None,
 8963        rate_limit=None,
 8964    ):
 8965        self.meta = meta if meta is not None else None
 8966        '''
 8967         Reserved for future use.
 8968        '''
 8969        self.rate_limit = rate_limit if rate_limit is not None else None
 8970        '''
 8971         Rate limit information.
 8972        '''
 8973
 8974    def __repr__(self):
 8975        return '<sdm.NodeDeleteResponse ' + \
 8976            'meta: ' + repr(self.meta) + ' ' +\
 8977            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 8978            '>'
 8979
 8980    def to_dict(self):
 8981        return {
 8982            'meta': self.meta,
 8983            'rate_limit': self.rate_limit,
 8984        }
 8985
 8986    @classmethod
 8987    def from_dict(cls, d):
 8988        return cls(
 8989            meta=d.get('meta'),
 8990            rate_limit=d.get('rate_limit'),
 8991        )
 8992
 8993
 8994class NodeGetResponse:
 8995    '''
 8996     NodeGetResponse returns a requested Node.
 8997    '''
 8998    __slots__ = [
 8999        'meta',
 9000        'node',
 9001        'rate_limit',
 9002    ]
 9003
 9004    def __init__(
 9005        self,
 9006        meta=None,
 9007        node=None,
 9008        rate_limit=None,
 9009    ):
 9010        self.meta = meta if meta is not None else None
 9011        '''
 9012         Reserved for future use.
 9013        '''
 9014        self.node = node if node is not None else None
 9015        '''
 9016         The requested Node.
 9017        '''
 9018        self.rate_limit = rate_limit if rate_limit is not None else None
 9019        '''
 9020         Rate limit information.
 9021        '''
 9022
 9023    def __repr__(self):
 9024        return '<sdm.NodeGetResponse ' + \
 9025            'meta: ' + repr(self.meta) + ' ' +\
 9026            'node: ' + repr(self.node) + ' ' +\
 9027            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 9028            '>'
 9029
 9030    def to_dict(self):
 9031        return {
 9032            'meta': self.meta,
 9033            'node': self.node,
 9034            'rate_limit': self.rate_limit,
 9035        }
 9036
 9037    @classmethod
 9038    def from_dict(cls, d):
 9039        return cls(
 9040            meta=d.get('meta'),
 9041            node=d.get('node'),
 9042            rate_limit=d.get('rate_limit'),
 9043        )
 9044
 9045
 9046class NodeUpdateResponse:
 9047    '''
 9048     NodeUpdateResponse returns the fields of a Node after it has been updated by
 9049     a NodeUpdateRequest.
 9050    '''
 9051    __slots__ = [
 9052        'meta',
 9053        'node',
 9054        'rate_limit',
 9055    ]
 9056
 9057    def __init__(
 9058        self,
 9059        meta=None,
 9060        node=None,
 9061        rate_limit=None,
 9062    ):
 9063        self.meta = meta if meta is not None else None
 9064        '''
 9065         Reserved for future use.
 9066        '''
 9067        self.node = node if node is not None else None
 9068        '''
 9069         The updated Node.
 9070        '''
 9071        self.rate_limit = rate_limit if rate_limit is not None else None
 9072        '''
 9073         Rate limit information.
 9074        '''
 9075
 9076    def __repr__(self):
 9077        return '<sdm.NodeUpdateResponse ' + \
 9078            'meta: ' + repr(self.meta) + ' ' +\
 9079            'node: ' + repr(self.node) + ' ' +\
 9080            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
 9081            '>'
 9082
 9083    def to_dict(self):
 9084        return {
 9085            'meta': self.meta,
 9086            'node': self.node,
 9087            'rate_limit': self.rate_limit,
 9088        }
 9089
 9090    @classmethod
 9091    def from_dict(cls, d):
 9092        return cls(
 9093            meta=d.get('meta'),
 9094            node=d.get('node'),
 9095            rate_limit=d.get('rate_limit'),
 9096        )
 9097
 9098
 9099class Oracle:
 9100    '''
 9101
 9102    '''
 9103    __slots__ = [
 9104        'bind_interface',
 9105        'database',
 9106        'egress_filter',
 9107        'healthy',
 9108        'hostname',
 9109        'id',
 9110        'name',
 9111        'password',
 9112        'port',
 9113        'port_override',
 9114        'secret_store_id',
 9115        'tags',
 9116        'tls_required',
 9117        'username',
 9118    ]
 9119
 9120    def __init__(
 9121        self,
 9122        bind_interface=None,
 9123        database=None,
 9124        egress_filter=None,
 9125        healthy=None,
 9126        hostname=None,
 9127        id=None,
 9128        name=None,
 9129        password=None,
 9130        port=None,
 9131        port_override=None,
 9132        secret_store_id=None,
 9133        tags=None,
 9134        tls_required=None,
 9135        username=None,
 9136    ):
 9137        self.bind_interface = bind_interface if bind_interface is not None else ''
 9138        '''
 9139         Bind interface
 9140        '''
 9141        self.database = database if database is not None else ''
 9142        '''
 9143
 9144        '''
 9145        self.egress_filter = egress_filter if egress_filter is not None else ''
 9146        '''
 9147         A filter applied to the routing logic to pin datasource to nodes.
 9148        '''
 9149        self.healthy = healthy if healthy is not None else False
 9150        '''
 9151         True if the datasource is reachable and the credentials are valid.
 9152        '''
 9153        self.hostname = hostname if hostname is not None else ''
 9154        '''
 9155
 9156        '''
 9157        self.id = id if id is not None else ''
 9158        '''
 9159         Unique identifier of the Resource.
 9160        '''
 9161        self.name = name if name is not None else ''
 9162        '''
 9163         Unique human-readable name of the Resource.
 9164        '''
 9165        self.password = password if password is not None else ''
 9166        '''
 9167
 9168        '''
 9169        self.port = port if port is not None else 0
 9170        '''
 9171
 9172        '''
 9173        self.port_override = port_override if port_override is not None else 0
 9174        '''
 9175
 9176        '''
 9177        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 9178        '''
 9179         ID of the secret store containing credentials for this resource, if any.
 9180        '''
 9181        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 9182        '''
 9183         Tags is a map of key, value pairs.
 9184        '''
 9185        self.tls_required = tls_required if tls_required is not None else False
 9186        '''
 9187
 9188        '''
 9189        self.username = username if username is not None else ''
 9190        '''
 9191
 9192        '''
 9193
 9194    def __repr__(self):
 9195        return '<sdm.Oracle ' + \
 9196            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 9197            'database: ' + repr(self.database) + ' ' +\
 9198            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 9199            'healthy: ' + repr(self.healthy) + ' ' +\
 9200            'hostname: ' + repr(self.hostname) + ' ' +\
 9201            'id: ' + repr(self.id) + ' ' +\
 9202            'name: ' + repr(self.name) + ' ' +\
 9203            'password: ' + repr(self.password) + ' ' +\
 9204            'port: ' + repr(self.port) + ' ' +\
 9205            'port_override: ' + repr(self.port_override) + ' ' +\
 9206            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 9207            'tags: ' + repr(self.tags) + ' ' +\
 9208            'tls_required: ' + repr(self.tls_required) + ' ' +\
 9209            'username: ' + repr(self.username) + ' ' +\
 9210            '>'
 9211
 9212    def to_dict(self):
 9213        return {
 9214            'bind_interface': self.bind_interface,
 9215            'database': self.database,
 9216            'egress_filter': self.egress_filter,
 9217            'healthy': self.healthy,
 9218            'hostname': self.hostname,
 9219            'id': self.id,
 9220            'name': self.name,
 9221            'password': self.password,
 9222            'port': self.port,
 9223            'port_override': self.port_override,
 9224            'secret_store_id': self.secret_store_id,
 9225            'tags': self.tags,
 9226            'tls_required': self.tls_required,
 9227            'username': self.username,
 9228        }
 9229
 9230    @classmethod
 9231    def from_dict(cls, d):
 9232        return cls(
 9233            bind_interface=d.get('bind_interface'),
 9234            database=d.get('database'),
 9235            egress_filter=d.get('egress_filter'),
 9236            healthy=d.get('healthy'),
 9237            hostname=d.get('hostname'),
 9238            id=d.get('id'),
 9239            name=d.get('name'),
 9240            password=d.get('password'),
 9241            port=d.get('port'),
 9242            port_override=d.get('port_override'),
 9243            secret_store_id=d.get('secret_store_id'),
 9244            tags=d.get('tags'),
 9245            tls_required=d.get('tls_required'),
 9246            username=d.get('username'),
 9247        )
 9248
 9249
 9250class Postgres:
 9251    '''
 9252
 9253    '''
 9254    __slots__ = [
 9255        'bind_interface',
 9256        'database',
 9257        'egress_filter',
 9258        'healthy',
 9259        'hostname',
 9260        'id',
 9261        'name',
 9262        'override_database',
 9263        'password',
 9264        'port',
 9265        'port_override',
 9266        'secret_store_id',
 9267        'tags',
 9268        'username',
 9269    ]
 9270
 9271    def __init__(
 9272        self,
 9273        bind_interface=None,
 9274        database=None,
 9275        egress_filter=None,
 9276        healthy=None,
 9277        hostname=None,
 9278        id=None,
 9279        name=None,
 9280        override_database=None,
 9281        password=None,
 9282        port=None,
 9283        port_override=None,
 9284        secret_store_id=None,
 9285        tags=None,
 9286        username=None,
 9287    ):
 9288        self.bind_interface = bind_interface if bind_interface is not None else ''
 9289        '''
 9290         Bind interface
 9291        '''
 9292        self.database = database if database is not None else ''
 9293        '''
 9294
 9295        '''
 9296        self.egress_filter = egress_filter if egress_filter is not None else ''
 9297        '''
 9298         A filter applied to the routing logic to pin datasource to nodes.
 9299        '''
 9300        self.healthy = healthy if healthy is not None else False
 9301        '''
 9302         True if the datasource is reachable and the credentials are valid.
 9303        '''
 9304        self.hostname = hostname if hostname is not None else ''
 9305        '''
 9306
 9307        '''
 9308        self.id = id if id is not None else ''
 9309        '''
 9310         Unique identifier of the Resource.
 9311        '''
 9312        self.name = name if name is not None else ''
 9313        '''
 9314         Unique human-readable name of the Resource.
 9315        '''
 9316        self.override_database = override_database if override_database is not None else False
 9317        '''
 9318
 9319        '''
 9320        self.password = password if password is not None else ''
 9321        '''
 9322
 9323        '''
 9324        self.port = port if port is not None else 0
 9325        '''
 9326
 9327        '''
 9328        self.port_override = port_override if port_override is not None else 0
 9329        '''
 9330
 9331        '''
 9332        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 9333        '''
 9334         ID of the secret store containing credentials for this resource, if any.
 9335        '''
 9336        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 9337        '''
 9338         Tags is a map of key, value pairs.
 9339        '''
 9340        self.username = username if username is not None else ''
 9341        '''
 9342
 9343        '''
 9344
 9345    def __repr__(self):
 9346        return '<sdm.Postgres ' + \
 9347            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 9348            'database: ' + repr(self.database) + ' ' +\
 9349            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 9350            'healthy: ' + repr(self.healthy) + ' ' +\
 9351            'hostname: ' + repr(self.hostname) + ' ' +\
 9352            'id: ' + repr(self.id) + ' ' +\
 9353            'name: ' + repr(self.name) + ' ' +\
 9354            'override_database: ' + repr(self.override_database) + ' ' +\
 9355            'password: ' + repr(self.password) + ' ' +\
 9356            'port: ' + repr(self.port) + ' ' +\
 9357            'port_override: ' + repr(self.port_override) + ' ' +\
 9358            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 9359            'tags: ' + repr(self.tags) + ' ' +\
 9360            'username: ' + repr(self.username) + ' ' +\
 9361            '>'
 9362
 9363    def to_dict(self):
 9364        return {
 9365            'bind_interface': self.bind_interface,
 9366            'database': self.database,
 9367            'egress_filter': self.egress_filter,
 9368            'healthy': self.healthy,
 9369            'hostname': self.hostname,
 9370            'id': self.id,
 9371            'name': self.name,
 9372            'override_database': self.override_database,
 9373            'password': self.password,
 9374            'port': self.port,
 9375            'port_override': self.port_override,
 9376            'secret_store_id': self.secret_store_id,
 9377            'tags': self.tags,
 9378            'username': self.username,
 9379        }
 9380
 9381    @classmethod
 9382    def from_dict(cls, d):
 9383        return cls(
 9384            bind_interface=d.get('bind_interface'),
 9385            database=d.get('database'),
 9386            egress_filter=d.get('egress_filter'),
 9387            healthy=d.get('healthy'),
 9388            hostname=d.get('hostname'),
 9389            id=d.get('id'),
 9390            name=d.get('name'),
 9391            override_database=d.get('override_database'),
 9392            password=d.get('password'),
 9393            port=d.get('port'),
 9394            port_override=d.get('port_override'),
 9395            secret_store_id=d.get('secret_store_id'),
 9396            tags=d.get('tags'),
 9397            username=d.get('username'),
 9398        )
 9399
 9400
 9401class Presto:
 9402    '''
 9403
 9404    '''
 9405    __slots__ = [
 9406        'bind_interface',
 9407        'database',
 9408        'egress_filter',
 9409        'healthy',
 9410        'hostname',
 9411        'id',
 9412        'name',
 9413        'password',
 9414        'port',
 9415        'port_override',
 9416        'secret_store_id',
 9417        'tags',
 9418        'tls_required',
 9419        'username',
 9420    ]
 9421
 9422    def __init__(
 9423        self,
 9424        bind_interface=None,
 9425        database=None,
 9426        egress_filter=None,
 9427        healthy=None,
 9428        hostname=None,
 9429        id=None,
 9430        name=None,
 9431        password=None,
 9432        port=None,
 9433        port_override=None,
 9434        secret_store_id=None,
 9435        tags=None,
 9436        tls_required=None,
 9437        username=None,
 9438    ):
 9439        self.bind_interface = bind_interface if bind_interface is not None else ''
 9440        '''
 9441         Bind interface
 9442        '''
 9443        self.database = database if database is not None else ''
 9444        '''
 9445
 9446        '''
 9447        self.egress_filter = egress_filter if egress_filter is not None else ''
 9448        '''
 9449         A filter applied to the routing logic to pin datasource to nodes.
 9450        '''
 9451        self.healthy = healthy if healthy is not None else False
 9452        '''
 9453         True if the datasource is reachable and the credentials are valid.
 9454        '''
 9455        self.hostname = hostname if hostname is not None else ''
 9456        '''
 9457
 9458        '''
 9459        self.id = id if id is not None else ''
 9460        '''
 9461         Unique identifier of the Resource.
 9462        '''
 9463        self.name = name if name is not None else ''
 9464        '''
 9465         Unique human-readable name of the Resource.
 9466        '''
 9467        self.password = password if password is not None else ''
 9468        '''
 9469
 9470        '''
 9471        self.port = port if port is not None else 0
 9472        '''
 9473
 9474        '''
 9475        self.port_override = port_override if port_override is not None else 0
 9476        '''
 9477
 9478        '''
 9479        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 9480        '''
 9481         ID of the secret store containing credentials for this resource, if any.
 9482        '''
 9483        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 9484        '''
 9485         Tags is a map of key, value pairs.
 9486        '''
 9487        self.tls_required = tls_required if tls_required is not None else False
 9488        '''
 9489
 9490        '''
 9491        self.username = username if username is not None else ''
 9492        '''
 9493
 9494        '''
 9495
 9496    def __repr__(self):
 9497        return '<sdm.Presto ' + \
 9498            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 9499            'database: ' + repr(self.database) + ' ' +\
 9500            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 9501            'healthy: ' + repr(self.healthy) + ' ' +\
 9502            'hostname: ' + repr(self.hostname) + ' ' +\
 9503            'id: ' + repr(self.id) + ' ' +\
 9504            'name: ' + repr(self.name) + ' ' +\
 9505            'password: ' + repr(self.password) + ' ' +\
 9506            'port: ' + repr(self.port) + ' ' +\
 9507            'port_override: ' + repr(self.port_override) + ' ' +\
 9508            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 9509            'tags: ' + repr(self.tags) + ' ' +\
 9510            'tls_required: ' + repr(self.tls_required) + ' ' +\
 9511            'username: ' + repr(self.username) + ' ' +\
 9512            '>'
 9513
 9514    def to_dict(self):
 9515        return {
 9516            'bind_interface': self.bind_interface,
 9517            'database': self.database,
 9518            'egress_filter': self.egress_filter,
 9519            'healthy': self.healthy,
 9520            'hostname': self.hostname,
 9521            'id': self.id,
 9522            'name': self.name,
 9523            'password': self.password,
 9524            'port': self.port,
 9525            'port_override': self.port_override,
 9526            'secret_store_id': self.secret_store_id,
 9527            'tags': self.tags,
 9528            'tls_required': self.tls_required,
 9529            'username': self.username,
 9530        }
 9531
 9532    @classmethod
 9533    def from_dict(cls, d):
 9534        return cls(
 9535            bind_interface=d.get('bind_interface'),
 9536            database=d.get('database'),
 9537            egress_filter=d.get('egress_filter'),
 9538            healthy=d.get('healthy'),
 9539            hostname=d.get('hostname'),
 9540            id=d.get('id'),
 9541            name=d.get('name'),
 9542            password=d.get('password'),
 9543            port=d.get('port'),
 9544            port_override=d.get('port_override'),
 9545            secret_store_id=d.get('secret_store_id'),
 9546            tags=d.get('tags'),
 9547            tls_required=d.get('tls_required'),
 9548            username=d.get('username'),
 9549        )
 9550
 9551
 9552class RDP:
 9553    '''
 9554
 9555    '''
 9556    __slots__ = [
 9557        'bind_interface',
 9558        'downgrade_nla_connections',
 9559        'egress_filter',
 9560        'healthy',
 9561        'hostname',
 9562        'id',
 9563        'name',
 9564        'password',
 9565        'port',
 9566        'port_override',
 9567        'secret_store_id',
 9568        'tags',
 9569        'username',
 9570    ]
 9571
 9572    def __init__(
 9573        self,
 9574        bind_interface=None,
 9575        downgrade_nla_connections=None,
 9576        egress_filter=None,
 9577        healthy=None,
 9578        hostname=None,
 9579        id=None,
 9580        name=None,
 9581        password=None,
 9582        port=None,
 9583        port_override=None,
 9584        secret_store_id=None,
 9585        tags=None,
 9586        username=None,
 9587    ):
 9588        self.bind_interface = bind_interface if bind_interface is not None else ''
 9589        '''
 9590         Bind interface
 9591        '''
 9592        self.downgrade_nla_connections = downgrade_nla_connections if downgrade_nla_connections is not None else False
 9593        '''
 9594
 9595        '''
 9596        self.egress_filter = egress_filter if egress_filter is not None else ''
 9597        '''
 9598         A filter applied to the routing logic to pin datasource to nodes.
 9599        '''
 9600        self.healthy = healthy if healthy is not None else False
 9601        '''
 9602         True if the datasource is reachable and the credentials are valid.
 9603        '''
 9604        self.hostname = hostname if hostname is not None else ''
 9605        '''
 9606
 9607        '''
 9608        self.id = id if id is not None else ''
 9609        '''
 9610         Unique identifier of the Resource.
 9611        '''
 9612        self.name = name if name is not None else ''
 9613        '''
 9614         Unique human-readable name of the Resource.
 9615        '''
 9616        self.password = password if password is not None else ''
 9617        '''
 9618
 9619        '''
 9620        self.port = port if port is not None else 0
 9621        '''
 9622
 9623        '''
 9624        self.port_override = port_override if port_override is not None else 0
 9625        '''
 9626
 9627        '''
 9628        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 9629        '''
 9630         ID of the secret store containing credentials for this resource, if any.
 9631        '''
 9632        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 9633        '''
 9634         Tags is a map of key, value pairs.
 9635        '''
 9636        self.username = username if username is not None else ''
 9637        '''
 9638
 9639        '''
 9640
 9641    def __repr__(self):
 9642        return '<sdm.RDP ' + \
 9643            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 9644            'downgrade_nla_connections: ' + repr(self.downgrade_nla_connections) + ' ' +\
 9645            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 9646            'healthy: ' + repr(self.healthy) + ' ' +\
 9647            'hostname: ' + repr(self.hostname) + ' ' +\
 9648            'id: ' + repr(self.id) + ' ' +\
 9649            'name: ' + repr(self.name) + ' ' +\
 9650            'password: ' + repr(self.password) + ' ' +\
 9651            'port: ' + repr(self.port) + ' ' +\
 9652            'port_override: ' + repr(self.port_override) + ' ' +\
 9653            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 9654            'tags: ' + repr(self.tags) + ' ' +\
 9655            'username: ' + repr(self.username) + ' ' +\
 9656            '>'
 9657
 9658    def to_dict(self):
 9659        return {
 9660            'bind_interface': self.bind_interface,
 9661            'downgrade_nla_connections': self.downgrade_nla_connections,
 9662            'egress_filter': self.egress_filter,
 9663            'healthy': self.healthy,
 9664            'hostname': self.hostname,
 9665            'id': self.id,
 9666            'name': self.name,
 9667            'password': self.password,
 9668            'port': self.port,
 9669            'port_override': self.port_override,
 9670            'secret_store_id': self.secret_store_id,
 9671            'tags': self.tags,
 9672            'username': self.username,
 9673        }
 9674
 9675    @classmethod
 9676    def from_dict(cls, d):
 9677        return cls(
 9678            bind_interface=d.get('bind_interface'),
 9679            downgrade_nla_connections=d.get('downgrade_nla_connections'),
 9680            egress_filter=d.get('egress_filter'),
 9681            healthy=d.get('healthy'),
 9682            hostname=d.get('hostname'),
 9683            id=d.get('id'),
 9684            name=d.get('name'),
 9685            password=d.get('password'),
 9686            port=d.get('port'),
 9687            port_override=d.get('port_override'),
 9688            secret_store_id=d.get('secret_store_id'),
 9689            tags=d.get('tags'),
 9690            username=d.get('username'),
 9691        )
 9692
 9693
 9694class RabbitMQAMQP091:
 9695    '''
 9696
 9697    '''
 9698    __slots__ = [
 9699        'bind_interface',
 9700        'egress_filter',
 9701        'healthy',
 9702        'hostname',
 9703        'id',
 9704        'name',
 9705        'password',
 9706        'port',
 9707        'port_override',
 9708        'secret_store_id',
 9709        'tags',
 9710        'tls_required',
 9711        'username',
 9712    ]
 9713
 9714    def __init__(
 9715        self,
 9716        bind_interface=None,
 9717        egress_filter=None,
 9718        healthy=None,
 9719        hostname=None,
 9720        id=None,
 9721        name=None,
 9722        password=None,
 9723        port=None,
 9724        port_override=None,
 9725        secret_store_id=None,
 9726        tags=None,
 9727        tls_required=None,
 9728        username=None,
 9729    ):
 9730        self.bind_interface = bind_interface if bind_interface is not None else ''
 9731        '''
 9732         Bind interface
 9733        '''
 9734        self.egress_filter = egress_filter if egress_filter is not None else ''
 9735        '''
 9736         A filter applied to the routing logic to pin datasource to nodes.
 9737        '''
 9738        self.healthy = healthy if healthy is not None else False
 9739        '''
 9740         True if the datasource is reachable and the credentials are valid.
 9741        '''
 9742        self.hostname = hostname if hostname is not None else ''
 9743        '''
 9744
 9745        '''
 9746        self.id = id if id is not None else ''
 9747        '''
 9748         Unique identifier of the Resource.
 9749        '''
 9750        self.name = name if name is not None else ''
 9751        '''
 9752         Unique human-readable name of the Resource.
 9753        '''
 9754        self.password = password if password is not None else ''
 9755        '''
 9756
 9757        '''
 9758        self.port = port if port is not None else 0
 9759        '''
 9760
 9761        '''
 9762        self.port_override = port_override if port_override is not None else 0
 9763        '''
 9764
 9765        '''
 9766        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 9767        '''
 9768         ID of the secret store containing credentials for this resource, if any.
 9769        '''
 9770        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 9771        '''
 9772         Tags is a map of key, value pairs.
 9773        '''
 9774        self.tls_required = tls_required if tls_required is not None else False
 9775        '''
 9776
 9777        '''
 9778        self.username = username if username is not None else ''
 9779        '''
 9780
 9781        '''
 9782
 9783    def __repr__(self):
 9784        return '<sdm.RabbitMQAMQP091 ' + \
 9785            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 9786            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 9787            'healthy: ' + repr(self.healthy) + ' ' +\
 9788            'hostname: ' + repr(self.hostname) + ' ' +\
 9789            'id: ' + repr(self.id) + ' ' +\
 9790            'name: ' + repr(self.name) + ' ' +\
 9791            'password: ' + repr(self.password) + ' ' +\
 9792            'port: ' + repr(self.port) + ' ' +\
 9793            'port_override: ' + repr(self.port_override) + ' ' +\
 9794            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 9795            'tags: ' + repr(self.tags) + ' ' +\
 9796            'tls_required: ' + repr(self.tls_required) + ' ' +\
 9797            'username: ' + repr(self.username) + ' ' +\
 9798            '>'
 9799
 9800    def to_dict(self):
 9801        return {
 9802            'bind_interface': self.bind_interface,
 9803            'egress_filter': self.egress_filter,
 9804            'healthy': self.healthy,
 9805            'hostname': self.hostname,
 9806            'id': self.id,
 9807            'name': self.name,
 9808            'password': self.password,
 9809            'port': self.port,
 9810            'port_override': self.port_override,
 9811            'secret_store_id': self.secret_store_id,
 9812            'tags': self.tags,
 9813            'tls_required': self.tls_required,
 9814            'username': self.username,
 9815        }
 9816
 9817    @classmethod
 9818    def from_dict(cls, d):
 9819        return cls(
 9820            bind_interface=d.get('bind_interface'),
 9821            egress_filter=d.get('egress_filter'),
 9822            healthy=d.get('healthy'),
 9823            hostname=d.get('hostname'),
 9824            id=d.get('id'),
 9825            name=d.get('name'),
 9826            password=d.get('password'),
 9827            port=d.get('port'),
 9828            port_override=d.get('port_override'),
 9829            secret_store_id=d.get('secret_store_id'),
 9830            tags=d.get('tags'),
 9831            tls_required=d.get('tls_required'),
 9832            username=d.get('username'),
 9833        )
 9834
 9835
 9836class RateLimitMetadata:
 9837    '''
 9838     RateLimitMetadata contains information about remaining requests avaialable
 9839     to the user over some timeframe.
 9840    '''
 9841    __slots__ = [
 9842        'bucket',
 9843        'limit',
 9844        'remaining',
 9845        'reset_at',
 9846    ]
 9847
 9848    def __init__(
 9849        self,
 9850        bucket=None,
 9851        limit=None,
 9852        remaining=None,
 9853        reset_at=None,
 9854    ):
 9855        self.bucket = bucket if bucket is not None else ''
 9856        '''
 9857         The bucket this user/token is associated with, which may be shared between
 9858         multiple users/tokens.
 9859        '''
 9860        self.limit = limit if limit is not None else 0
 9861        '''
 9862         How many total requests the user/token is authorized to make before being
 9863         rate limited.
 9864        '''
 9865        self.remaining = remaining if remaining is not None else 0
 9866        '''
 9867         How many remaining requests out of the limit are still avaialable.
 9868        '''
 9869        self.reset_at = reset_at if reset_at is not None else None
 9870        '''
 9871         The time when remaining will be reset to limit.
 9872        '''
 9873
 9874    def __repr__(self):
 9875        return '<sdm.RateLimitMetadata ' + \
 9876            'bucket: ' + repr(self.bucket) + ' ' +\
 9877            'limit: ' + repr(self.limit) + ' ' +\
 9878            'remaining: ' + repr(self.remaining) + ' ' +\
 9879            'reset_at: ' + repr(self.reset_at) + ' ' +\
 9880            '>'
 9881
 9882    def to_dict(self):
 9883        return {
 9884            'bucket': self.bucket,
 9885            'limit': self.limit,
 9886            'remaining': self.remaining,
 9887            'reset_at': self.reset_at,
 9888        }
 9889
 9890    @classmethod
 9891    def from_dict(cls, d):
 9892        return cls(
 9893            bucket=d.get('bucket'),
 9894            limit=d.get('limit'),
 9895            remaining=d.get('remaining'),
 9896            reset_at=d.get('reset_at'),
 9897        )
 9898
 9899
 9900class RawTCP:
 9901    '''
 9902
 9903    '''
 9904    __slots__ = [
 9905        'bind_interface',
 9906        'egress_filter',
 9907        'healthy',
 9908        'hostname',
 9909        'id',
 9910        'name',
 9911        'port',
 9912        'port_override',
 9913        'secret_store_id',
 9914        'tags',
 9915    ]
 9916
 9917    def __init__(
 9918        self,
 9919        bind_interface=None,
 9920        egress_filter=None,
 9921        healthy=None,
 9922        hostname=None,
 9923        id=None,
 9924        name=None,
 9925        port=None,
 9926        port_override=None,
 9927        secret_store_id=None,
 9928        tags=None,
 9929    ):
 9930        self.bind_interface = bind_interface if bind_interface is not None else ''
 9931        '''
 9932         Bind interface
 9933        '''
 9934        self.egress_filter = egress_filter if egress_filter is not None else ''
 9935        '''
 9936         A filter applied to the routing logic to pin datasource to nodes.
 9937        '''
 9938        self.healthy = healthy if healthy is not None else False
 9939        '''
 9940         True if the datasource is reachable and the credentials are valid.
 9941        '''
 9942        self.hostname = hostname if hostname is not None else ''
 9943        '''
 9944
 9945        '''
 9946        self.id = id if id is not None else ''
 9947        '''
 9948         Unique identifier of the Resource.
 9949        '''
 9950        self.name = name if name is not None else ''
 9951        '''
 9952         Unique human-readable name of the Resource.
 9953        '''
 9954        self.port = port if port is not None else 0
 9955        '''
 9956
 9957        '''
 9958        self.port_override = port_override if port_override is not None else 0
 9959        '''
 9960
 9961        '''
 9962        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 9963        '''
 9964         ID of the secret store containing credentials for this resource, if any.
 9965        '''
 9966        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 9967        '''
 9968         Tags is a map of key, value pairs.
 9969        '''
 9970
 9971    def __repr__(self):
 9972        return '<sdm.RawTCP ' + \
 9973            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 9974            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 9975            'healthy: ' + repr(self.healthy) + ' ' +\
 9976            'hostname: ' + repr(self.hostname) + ' ' +\
 9977            'id: ' + repr(self.id) + ' ' +\
 9978            'name: ' + repr(self.name) + ' ' +\
 9979            'port: ' + repr(self.port) + ' ' +\
 9980            'port_override: ' + repr(self.port_override) + ' ' +\
 9981            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 9982            'tags: ' + repr(self.tags) + ' ' +\
 9983            '>'
 9984
 9985    def to_dict(self):
 9986        return {
 9987            'bind_interface': self.bind_interface,
 9988            'egress_filter': self.egress_filter,
 9989            'healthy': self.healthy,
 9990            'hostname': self.hostname,
 9991            'id': self.id,
 9992            'name': self.name,
 9993            'port': self.port,
 9994            'port_override': self.port_override,
 9995            'secret_store_id': self.secret_store_id,
 9996            'tags': self.tags,
 9997        }
 9998
 9999    @classmethod
10000    def from_dict(cls, d):
10001        return cls(
10002            bind_interface=d.get('bind_interface'),
10003            egress_filter=d.get('egress_filter'),
10004            healthy=d.get('healthy'),
10005            hostname=d.get('hostname'),
10006            id=d.get('id'),
10007            name=d.get('name'),
10008            port=d.get('port'),
10009            port_override=d.get('port_override'),
10010            secret_store_id=d.get('secret_store_id'),
10011            tags=d.get('tags'),
10012        )
10013
10014
10015class Redis:
10016    '''
10017
10018    '''
10019    __slots__ = [
10020        'bind_interface',
10021        'egress_filter',
10022        'healthy',
10023        'hostname',
10024        'id',
10025        'name',
10026        'password',
10027        'port',
10028        'port_override',
10029        'secret_store_id',
10030        'tags',
10031    ]
10032
10033    def __init__(
10034        self,
10035        bind_interface=None,
10036        egress_filter=None,
10037        healthy=None,
10038        hostname=None,
10039        id=None,
10040        name=None,
10041        password=None,
10042        port=None,
10043        port_override=None,
10044        secret_store_id=None,
10045        tags=None,
10046    ):
10047        self.bind_interface = bind_interface if bind_interface is not None else ''
10048        '''
10049         Bind interface
10050        '''
10051        self.egress_filter = egress_filter if egress_filter is not None else ''
10052        '''
10053         A filter applied to the routing logic to pin datasource to nodes.
10054        '''
10055        self.healthy = healthy if healthy is not None else False
10056        '''
10057         True if the datasource is reachable and the credentials are valid.
10058        '''
10059        self.hostname = hostname if hostname is not None else ''
10060        '''
10061
10062        '''
10063        self.id = id if id is not None else ''
10064        '''
10065         Unique identifier of the Resource.
10066        '''
10067        self.name = name if name is not None else ''
10068        '''
10069         Unique human-readable name of the Resource.
10070        '''
10071        self.password = password if password is not None else ''
10072        '''
10073
10074        '''
10075        self.port = port if port is not None else 0
10076        '''
10077
10078        '''
10079        self.port_override = port_override if port_override is not None else 0
10080        '''
10081
10082        '''
10083        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
10084        '''
10085         ID of the secret store containing credentials for this resource, if any.
10086        '''
10087        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10088        '''
10089         Tags is a map of key, value pairs.
10090        '''
10091
10092    def __repr__(self):
10093        return '<sdm.Redis ' + \
10094            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
10095            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
10096            'healthy: ' + repr(self.healthy) + ' ' +\
10097            'hostname: ' + repr(self.hostname) + ' ' +\
10098            'id: ' + repr(self.id) + ' ' +\
10099            'name: ' + repr(self.name) + ' ' +\
10100            'password: ' + repr(self.password) + ' ' +\
10101            'port: ' + repr(self.port) + ' ' +\
10102            'port_override: ' + repr(self.port_override) + ' ' +\
10103            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
10104            'tags: ' + repr(self.tags) + ' ' +\
10105            '>'
10106
10107    def to_dict(self):
10108        return {
10109            'bind_interface': self.bind_interface,
10110            'egress_filter': self.egress_filter,
10111            'healthy': self.healthy,
10112            'hostname': self.hostname,
10113            'id': self.id,
10114            'name': self.name,
10115            'password': self.password,
10116            'port': self.port,
10117            'port_override': self.port_override,
10118            'secret_store_id': self.secret_store_id,
10119            'tags': self.tags,
10120        }
10121
10122    @classmethod
10123    def from_dict(cls, d):
10124        return cls(
10125            bind_interface=d.get('bind_interface'),
10126            egress_filter=d.get('egress_filter'),
10127            healthy=d.get('healthy'),
10128            hostname=d.get('hostname'),
10129            id=d.get('id'),
10130            name=d.get('name'),
10131            password=d.get('password'),
10132            port=d.get('port'),
10133            port_override=d.get('port_override'),
10134            secret_store_id=d.get('secret_store_id'),
10135            tags=d.get('tags'),
10136        )
10137
10138
10139class Redshift:
10140    '''
10141
10142    '''
10143    __slots__ = [
10144        'bind_interface',
10145        'database',
10146        'egress_filter',
10147        'healthy',
10148        'hostname',
10149        'id',
10150        'name',
10151        'override_database',
10152        'password',
10153        'port',
10154        'port_override',
10155        'secret_store_id',
10156        'tags',
10157        'username',
10158    ]
10159
10160    def __init__(
10161        self,
10162        bind_interface=None,
10163        database=None,
10164        egress_filter=None,
10165        healthy=None,
10166        hostname=None,
10167        id=None,
10168        name=None,
10169        override_database=None,
10170        password=None,
10171        port=None,
10172        port_override=None,
10173        secret_store_id=None,
10174        tags=None,
10175        username=None,
10176    ):
10177        self.bind_interface = bind_interface if bind_interface is not None else ''
10178        '''
10179         Bind interface
10180        '''
10181        self.database = database if database is not None else ''
10182        '''
10183
10184        '''
10185        self.egress_filter = egress_filter if egress_filter is not None else ''
10186        '''
10187         A filter applied to the routing logic to pin datasource to nodes.
10188        '''
10189        self.healthy = healthy if healthy is not None else False
10190        '''
10191         True if the datasource is reachable and the credentials are valid.
10192        '''
10193        self.hostname = hostname if hostname is not None else ''
10194        '''
10195
10196        '''
10197        self.id = id if id is not None else ''
10198        '''
10199         Unique identifier of the Resource.
10200        '''
10201        self.name = name if name is not None else ''
10202        '''
10203         Unique human-readable name of the Resource.
10204        '''
10205        self.override_database = override_database if override_database is not None else False
10206        '''
10207
10208        '''
10209        self.password = password if password is not None else ''
10210        '''
10211
10212        '''
10213        self.port = port if port is not None else 0
10214        '''
10215
10216        '''
10217        self.port_override = port_override if port_override is not None else 0
10218        '''
10219
10220        '''
10221        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
10222        '''
10223         ID of the secret store containing credentials for this resource, if any.
10224        '''
10225        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10226        '''
10227         Tags is a map of key, value pairs.
10228        '''
10229        self.username = username if username is not None else ''
10230        '''
10231
10232        '''
10233
10234    def __repr__(self):
10235        return '<sdm.Redshift ' + \
10236            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
10237            'database: ' + repr(self.database) + ' ' +\
10238            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
10239            'healthy: ' + repr(self.healthy) + ' ' +\
10240            'hostname: ' + repr(self.hostname) + ' ' +\
10241            'id: ' + repr(self.id) + ' ' +\
10242            'name: ' + repr(self.name) + ' ' +\
10243            'override_database: ' + repr(self.override_database) + ' ' +\
10244            'password: ' + repr(self.password) + ' ' +\
10245            'port: ' + repr(self.port) + ' ' +\
10246            'port_override: ' + repr(self.port_override) + ' ' +\
10247            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
10248            'tags: ' + repr(self.tags) + ' ' +\
10249            'username: ' + repr(self.username) + ' ' +\
10250            '>'
10251
10252    def to_dict(self):
10253        return {
10254            'bind_interface': self.bind_interface,
10255            'database': self.database,
10256            'egress_filter': self.egress_filter,
10257            'healthy': self.healthy,
10258            'hostname': self.hostname,
10259            'id': self.id,
10260            'name': self.name,
10261            'override_database': self.override_database,
10262            'password': self.password,
10263            'port': self.port,
10264            'port_override': self.port_override,
10265            'secret_store_id': self.secret_store_id,
10266            'tags': self.tags,
10267            'username': self.username,
10268        }
10269
10270    @classmethod
10271    def from_dict(cls, d):
10272        return cls(
10273            bind_interface=d.get('bind_interface'),
10274            database=d.get('database'),
10275            egress_filter=d.get('egress_filter'),
10276            healthy=d.get('healthy'),
10277            hostname=d.get('hostname'),
10278            id=d.get('id'),
10279            name=d.get('name'),
10280            override_database=d.get('override_database'),
10281            password=d.get('password'),
10282            port=d.get('port'),
10283            port_override=d.get('port_override'),
10284            secret_store_id=d.get('secret_store_id'),
10285            tags=d.get('tags'),
10286            username=d.get('username'),
10287        )
10288
10289
10290class Relay:
10291    '''
10292     Relay represents a StrongDM CLI installation running in relay mode.
10293    '''
10294    __slots__ = [
10295        'gateway_filter',
10296        'id',
10297        'name',
10298        'state',
10299        'tags',
10300    ]
10301
10302    def __init__(
10303        self,
10304        gateway_filter=None,
10305        id=None,
10306        name=None,
10307        state=None,
10308        tags=None,
10309    ):
10310        self.gateway_filter = gateway_filter if gateway_filter is not None else ''
10311        '''
10312         GatewayFilter can be used to restrict the peering between relays and
10313         gateways.
10314        '''
10315        self.id = id if id is not None else ''
10316        '''
10317         Unique identifier of the Relay.
10318        '''
10319        self.name = name if name is not None else ''
10320        '''
10321         Unique human-readable name of the Relay. Node names must include only letters, numbers, and hyphens (no spaces, underscores, or other special characters). Generated if not provided on create.
10322        '''
10323        self.state = state if state is not None else ''
10324        '''
10325         The current state of the relay. One of: "new", "verifying_restart",
10326         "awaiting_restart", "restarting", "started", "stopped", "dead",
10327         "unknown".
10328        '''
10329        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10330        '''
10331         Tags is a map of key, value pairs.
10332        '''
10333
10334    def __repr__(self):
10335        return '<sdm.Relay ' + \
10336            'gateway_filter: ' + repr(self.gateway_filter) + ' ' +\
10337            'id: ' + repr(self.id) + ' ' +\
10338            'name: ' + repr(self.name) + ' ' +\
10339            'state: ' + repr(self.state) + ' ' +\
10340            'tags: ' + repr(self.tags) + ' ' +\
10341            '>'
10342
10343    def to_dict(self):
10344        return {
10345            'gateway_filter': self.gateway_filter,
10346            'id': self.id,
10347            'name': self.name,
10348            'state': self.state,
10349            'tags': self.tags,
10350        }
10351
10352    @classmethod
10353    def from_dict(cls, d):
10354        return cls(
10355            gateway_filter=d.get('gateway_filter'),
10356            id=d.get('id'),
10357            name=d.get('name'),
10358            state=d.get('state'),
10359            tags=d.get('tags'),
10360        )
10361
10362
10363class RemoteIdentity:
10364    '''
10365     RemoteIdentities define the username to be used for a specific account
10366     when connecting to a remote resource using that group.
10367    '''
10368    __slots__ = [
10369        'account_id',
10370        'id',
10371        'remote_identity_group_id',
10372        'username',
10373    ]
10374
10375    def __init__(
10376        self,
10377        account_id=None,
10378        id=None,
10379        remote_identity_group_id=None,
10380        username=None,
10381    ):
10382        self.account_id = account_id if account_id is not None else ''
10383        '''
10384         The account for this remote identity.
10385        '''
10386        self.id = id if id is not None else ''
10387        '''
10388         Unique identifier of the RemoteIdentity.
10389        '''
10390        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
10391        '''
10392         The remote identity group.
10393        '''
10394        self.username = username if username is not None else ''
10395        '''
10396         The username to be used as the remote identity for this account.
10397        '''
10398
10399    def __repr__(self):
10400        return '<sdm.RemoteIdentity ' + \
10401            'account_id: ' + repr(self.account_id) + ' ' +\
10402            'id: ' + repr(self.id) + ' ' +\
10403            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
10404            'username: ' + repr(self.username) + ' ' +\
10405            '>'
10406
10407    def to_dict(self):
10408        return {
10409            'account_id': self.account_id,
10410            'id': self.id,
10411            'remote_identity_group_id': self.remote_identity_group_id,
10412            'username': self.username,
10413        }
10414
10415    @classmethod
10416    def from_dict(cls, d):
10417        return cls(
10418            account_id=d.get('account_id'),
10419            id=d.get('id'),
10420            remote_identity_group_id=d.get('remote_identity_group_id'),
10421            username=d.get('username'),
10422        )
10423
10424
10425class RemoteIdentityCreateResponse:
10426    '''
10427     RemoteIdentityCreateResponse reports how the RemoteIdentities were created in the system.
10428    '''
10429    __slots__ = [
10430        'meta',
10431        'rate_limit',
10432        'remote_identity',
10433    ]
10434
10435    def __init__(
10436        self,
10437        meta=None,
10438        rate_limit=None,
10439        remote_identity=None,
10440    ):
10441        self.meta = meta if meta is not None else None
10442        '''
10443         Reserved for future use.
10444        '''
10445        self.rate_limit = rate_limit if rate_limit is not None else None
10446        '''
10447         Rate limit information.
10448        '''
10449        self.remote_identity = remote_identity if remote_identity is not None else None
10450        '''
10451         The created RemoteIdentity.
10452        '''
10453
10454    def __repr__(self):
10455        return '<sdm.RemoteIdentityCreateResponse ' + \
10456            'meta: ' + repr(self.meta) + ' ' +\
10457            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10458            'remote_identity: ' + repr(self.remote_identity) + ' ' +\
10459            '>'
10460
10461    def to_dict(self):
10462        return {
10463            'meta': self.meta,
10464            'rate_limit': self.rate_limit,
10465            'remote_identity': self.remote_identity,
10466        }
10467
10468    @classmethod
10469    def from_dict(cls, d):
10470        return cls(
10471            meta=d.get('meta'),
10472            rate_limit=d.get('rate_limit'),
10473            remote_identity=d.get('remote_identity'),
10474        )
10475
10476
10477class RemoteIdentityDeleteResponse:
10478    '''
10479     RemoteIdentityDeleteResponse returns information about a RemoteIdentity that was deleted.
10480    '''
10481    __slots__ = [
10482        'meta',
10483        'rate_limit',
10484    ]
10485
10486    def __init__(
10487        self,
10488        meta=None,
10489        rate_limit=None,
10490    ):
10491        self.meta = meta if meta is not None else None
10492        '''
10493         Reserved for future use.
10494        '''
10495        self.rate_limit = rate_limit if rate_limit is not None else None
10496        '''
10497         Rate limit information.
10498        '''
10499
10500    def __repr__(self):
10501        return '<sdm.RemoteIdentityDeleteResponse ' + \
10502            'meta: ' + repr(self.meta) + ' ' +\
10503            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10504            '>'
10505
10506    def to_dict(self):
10507        return {
10508            'meta': self.meta,
10509            'rate_limit': self.rate_limit,
10510        }
10511
10512    @classmethod
10513    def from_dict(cls, d):
10514        return cls(
10515            meta=d.get('meta'),
10516            rate_limit=d.get('rate_limit'),
10517        )
10518
10519
10520class RemoteIdentityGetResponse:
10521    '''
10522     RemoteIdentityGetResponse returns a requested RemoteIdentity.
10523    '''
10524    __slots__ = [
10525        'meta',
10526        'rate_limit',
10527        'remote_identity',
10528    ]
10529
10530    def __init__(
10531        self,
10532        meta=None,
10533        rate_limit=None,
10534        remote_identity=None,
10535    ):
10536        self.meta = meta if meta is not None else None
10537        '''
10538         Reserved for future use.
10539        '''
10540        self.rate_limit = rate_limit if rate_limit is not None else None
10541        '''
10542         Rate limit information.
10543        '''
10544        self.remote_identity = remote_identity if remote_identity is not None else None
10545        '''
10546         The requested RemoteIdentity.
10547        '''
10548
10549    def __repr__(self):
10550        return '<sdm.RemoteIdentityGetResponse ' + \
10551            'meta: ' + repr(self.meta) + ' ' +\
10552            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10553            'remote_identity: ' + repr(self.remote_identity) + ' ' +\
10554            '>'
10555
10556    def to_dict(self):
10557        return {
10558            'meta': self.meta,
10559            'rate_limit': self.rate_limit,
10560            'remote_identity': self.remote_identity,
10561        }
10562
10563    @classmethod
10564    def from_dict(cls, d):
10565        return cls(
10566            meta=d.get('meta'),
10567            rate_limit=d.get('rate_limit'),
10568            remote_identity=d.get('remote_identity'),
10569        )
10570
10571
10572class RemoteIdentityGroup:
10573    '''
10574     A RemoteIdentityGroup defines a group of remote identities.
10575    '''
10576    __slots__ = [
10577        'id',
10578        'name',
10579    ]
10580
10581    def __init__(
10582        self,
10583        id=None,
10584        name=None,
10585    ):
10586        self.id = id if id is not None else ''
10587        '''
10588         Unique identifier of the RemoteIdentityGroup.
10589        '''
10590        self.name = name if name is not None else ''
10591        '''
10592         Unique human-readable name of the RemoteIdentityGroup.
10593        '''
10594
10595    def __repr__(self):
10596        return '<sdm.RemoteIdentityGroup ' + \
10597            'id: ' + repr(self.id) + ' ' +\
10598            'name: ' + repr(self.name) + ' ' +\
10599            '>'
10600
10601    def to_dict(self):
10602        return {
10603            'id': self.id,
10604            'name': self.name,
10605        }
10606
10607    @classmethod
10608    def from_dict(cls, d):
10609        return cls(
10610            id=d.get('id'),
10611            name=d.get('name'),
10612        )
10613
10614
10615class RemoteIdentityGroupGetResponse:
10616    '''
10617     RemoteIdentityGroupGetResponse returns a requested RemoteIdentityGroup.
10618    '''
10619    __slots__ = [
10620        'meta',
10621        'rate_limit',
10622        'remote_identity_group',
10623    ]
10624
10625    def __init__(
10626        self,
10627        meta=None,
10628        rate_limit=None,
10629        remote_identity_group=None,
10630    ):
10631        self.meta = meta if meta is not None else None
10632        '''
10633         Reserved for future use.
10634        '''
10635        self.rate_limit = rate_limit if rate_limit is not None else None
10636        '''
10637         Rate limit information.
10638        '''
10639        self.remote_identity_group = remote_identity_group if remote_identity_group is not None else None
10640        '''
10641         The requested RemoteIdentityGroup.
10642        '''
10643
10644    def __repr__(self):
10645        return '<sdm.RemoteIdentityGroupGetResponse ' + \
10646            'meta: ' + repr(self.meta) + ' ' +\
10647            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10648            'remote_identity_group: ' + repr(self.remote_identity_group) + ' ' +\
10649            '>'
10650
10651    def to_dict(self):
10652        return {
10653            'meta': self.meta,
10654            'rate_limit': self.rate_limit,
10655            'remote_identity_group': self.remote_identity_group,
10656        }
10657
10658    @classmethod
10659    def from_dict(cls, d):
10660        return cls(
10661            meta=d.get('meta'),
10662            rate_limit=d.get('rate_limit'),
10663            remote_identity_group=d.get('remote_identity_group'),
10664        )
10665
10666
10667class RemoteIdentityUpdateResponse:
10668    '''
10669     RemoteIdentityUpdateResponse returns the fields of a RemoteIdentity after it has been updated by
10670     a RemoteIdentityUpdateRequest.
10671    '''
10672    __slots__ = [
10673        'meta',
10674        'rate_limit',
10675        'remote_identity',
10676    ]
10677
10678    def __init__(
10679        self,
10680        meta=None,
10681        rate_limit=None,
10682        remote_identity=None,
10683    ):
10684        self.meta = meta if meta is not None else None
10685        '''
10686         Reserved for future use.
10687        '''
10688        self.rate_limit = rate_limit if rate_limit is not None else None
10689        '''
10690         Rate limit information.
10691        '''
10692        self.remote_identity = remote_identity if remote_identity is not None else None
10693        '''
10694         The updated RemoteIdentity.
10695        '''
10696
10697    def __repr__(self):
10698        return '<sdm.RemoteIdentityUpdateResponse ' + \
10699            'meta: ' + repr(self.meta) + ' ' +\
10700            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10701            'remote_identity: ' + repr(self.remote_identity) + ' ' +\
10702            '>'
10703
10704    def to_dict(self):
10705        return {
10706            'meta': self.meta,
10707            'rate_limit': self.rate_limit,
10708            'remote_identity': self.remote_identity,
10709        }
10710
10711    @classmethod
10712    def from_dict(cls, d):
10713        return cls(
10714            meta=d.get('meta'),
10715            rate_limit=d.get('rate_limit'),
10716            remote_identity=d.get('remote_identity'),
10717        )
10718
10719
10720class ResourceCreateResponse:
10721    '''
10722     ResourceCreateResponse reports how the Resources were created in the system.
10723    '''
10724    __slots__ = [
10725        'meta',
10726        'rate_limit',
10727        'resource',
10728    ]
10729
10730    def __init__(
10731        self,
10732        meta=None,
10733        rate_limit=None,
10734        resource=None,
10735    ):
10736        self.meta = meta if meta is not None else None
10737        '''
10738         Reserved for future use.
10739        '''
10740        self.rate_limit = rate_limit if rate_limit is not None else None
10741        '''
10742         Rate limit information.
10743        '''
10744        self.resource = resource if resource is not None else None
10745        '''
10746         The created Resource.
10747        '''
10748
10749    def __repr__(self):
10750        return '<sdm.ResourceCreateResponse ' + \
10751            'meta: ' + repr(self.meta) + ' ' +\
10752            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10753            'resource: ' + repr(self.resource) + ' ' +\
10754            '>'
10755
10756    def to_dict(self):
10757        return {
10758            'meta': self.meta,
10759            'rate_limit': self.rate_limit,
10760            'resource': self.resource,
10761        }
10762
10763    @classmethod
10764    def from_dict(cls, d):
10765        return cls(
10766            meta=d.get('meta'),
10767            rate_limit=d.get('rate_limit'),
10768            resource=d.get('resource'),
10769        )
10770
10771
10772class ResourceDeleteResponse:
10773    '''
10774     ResourceDeleteResponse returns information about a Resource that was deleted.
10775    '''
10776    __slots__ = [
10777        'meta',
10778        'rate_limit',
10779    ]
10780
10781    def __init__(
10782        self,
10783        meta=None,
10784        rate_limit=None,
10785    ):
10786        self.meta = meta if meta is not None else None
10787        '''
10788         Reserved for future use.
10789        '''
10790        self.rate_limit = rate_limit if rate_limit is not None else None
10791        '''
10792         Rate limit information.
10793        '''
10794
10795    def __repr__(self):
10796        return '<sdm.ResourceDeleteResponse ' + \
10797            'meta: ' + repr(self.meta) + ' ' +\
10798            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10799            '>'
10800
10801    def to_dict(self):
10802        return {
10803            'meta': self.meta,
10804            'rate_limit': self.rate_limit,
10805        }
10806
10807    @classmethod
10808    def from_dict(cls, d):
10809        return cls(
10810            meta=d.get('meta'),
10811            rate_limit=d.get('rate_limit'),
10812        )
10813
10814
10815class ResourceGetResponse:
10816    '''
10817     ResourceGetResponse returns a requested Resource.
10818    '''
10819    __slots__ = [
10820        'meta',
10821        'rate_limit',
10822        'resource',
10823    ]
10824
10825    def __init__(
10826        self,
10827        meta=None,
10828        rate_limit=None,
10829        resource=None,
10830    ):
10831        self.meta = meta if meta is not None else None
10832        '''
10833         Reserved for future use.
10834        '''
10835        self.rate_limit = rate_limit if rate_limit is not None else None
10836        '''
10837         Rate limit information.
10838        '''
10839        self.resource = resource if resource is not None else None
10840        '''
10841         The requested Resource.
10842        '''
10843
10844    def __repr__(self):
10845        return '<sdm.ResourceGetResponse ' + \
10846            'meta: ' + repr(self.meta) + ' ' +\
10847            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10848            'resource: ' + repr(self.resource) + ' ' +\
10849            '>'
10850
10851    def to_dict(self):
10852        return {
10853            'meta': self.meta,
10854            'rate_limit': self.rate_limit,
10855            'resource': self.resource,
10856        }
10857
10858    @classmethod
10859    def from_dict(cls, d):
10860        return cls(
10861            meta=d.get('meta'),
10862            rate_limit=d.get('rate_limit'),
10863            resource=d.get('resource'),
10864        )
10865
10866
10867class ResourceUpdateResponse:
10868    '''
10869     ResourceUpdateResponse returns the fields of a Resource after it has been updated by
10870     a ResourceUpdateRequest.
10871    '''
10872    __slots__ = [
10873        'meta',
10874        'rate_limit',
10875        'resource',
10876    ]
10877
10878    def __init__(
10879        self,
10880        meta=None,
10881        rate_limit=None,
10882        resource=None,
10883    ):
10884        self.meta = meta if meta is not None else None
10885        '''
10886         Reserved for future use.
10887        '''
10888        self.rate_limit = rate_limit if rate_limit is not None else None
10889        '''
10890         Rate limit information.
10891        '''
10892        self.resource = resource if resource is not None else None
10893        '''
10894         The updated Resource.
10895        '''
10896
10897    def __repr__(self):
10898        return '<sdm.ResourceUpdateResponse ' + \
10899            'meta: ' + repr(self.meta) + ' ' +\
10900            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10901            'resource: ' + repr(self.resource) + ' ' +\
10902            '>'
10903
10904    def to_dict(self):
10905        return {
10906            'meta': self.meta,
10907            'rate_limit': self.rate_limit,
10908            'resource': self.resource,
10909        }
10910
10911    @classmethod
10912    def from_dict(cls, d):
10913        return cls(
10914            meta=d.get('meta'),
10915            rate_limit=d.get('rate_limit'),
10916            resource=d.get('resource'),
10917        )
10918
10919
10920class Role:
10921    '''
10922     A Role has a list of access rules which determine which Resources the members
10923     of the Role have access to. An Account can be a member of multiple Roles via
10924     AccountAttachments.
10925    '''
10926    __slots__ = [
10927        'access_rules',
10928        'composite',
10929        'id',
10930        'name',
10931        'tags',
10932    ]
10933
10934    def __init__(
10935        self,
10936        access_rules=None,
10937        composite=None,
10938        id=None,
10939        name=None,
10940        tags=None,
10941    ):
10942        self.access_rules = access_rules if access_rules is not None else _porcelain_zero_value_access_rules(
10943        )
10944        '''
10945         AccessRules is a list of access rules defining the resources this Role has access to.
10946        '''
10947        self.composite = composite if composite is not None else False
10948        '''
10949         Composite is true if the Role is a composite role.
10950         
10951         Deprecated: composite roles are deprecated, use multi-role via
10952         AccountAttachments instead.
10953        '''
10954        self.id = id if id is not None else ''
10955        '''
10956         Unique identifier of the Role.
10957        '''
10958        self.name = name if name is not None else ''
10959        '''
10960         Unique human-readable name of the Role.
10961        '''
10962        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10963        '''
10964         Tags is a map of key, value pairs.
10965        '''
10966
10967    def __repr__(self):
10968        return '<sdm.Role ' + \
10969            'access_rules: ' + repr(self.access_rules) + ' ' +\
10970            'composite: ' + repr(self.composite) + ' ' +\
10971            'id: ' + repr(self.id) + ' ' +\
10972            'name: ' + repr(self.name) + ' ' +\
10973            'tags: ' + repr(self.tags) + ' ' +\
10974            '>'
10975
10976    def to_dict(self):
10977        return {
10978            'access_rules': self.access_rules,
10979            'composite': self.composite,
10980            'id': self.id,
10981            'name': self.name,
10982            'tags': self.tags,
10983        }
10984
10985    @classmethod
10986    def from_dict(cls, d):
10987        return cls(
10988            access_rules=d.get('access_rules'),
10989            composite=d.get('composite'),
10990            id=d.get('id'),
10991            name=d.get('name'),
10992            tags=d.get('tags'),
10993        )
10994
10995
10996class RoleAttachment:
10997    '''
10998     A RoleAttachment assigns a role to a composite role.
10999     
11000     Deprecated: use multi-role via AccountAttachments instead.
11001    '''
11002    __slots__ = [
11003        'attached_role_id',
11004        'composite_role_id',
11005        'id',
11006    ]
11007
11008    def __init__(
11009        self,
11010        attached_role_id=None,
11011        composite_role_id=None,
11012        id=None,
11013    ):
11014        self.attached_role_id = attached_role_id if attached_role_id is not None else ''
11015        '''
11016         The id of the attached role of this RoleAttachment.
11017        '''
11018        self.composite_role_id = composite_role_id if composite_role_id is not None else ''
11019        '''
11020         The id of the composite role of this RoleAttachment.
11021        '''
11022        self.id = id if id is not None else ''
11023        '''
11024         Unique identifier of the RoleAttachment.
11025        '''
11026
11027    def __repr__(self):
11028        return '<sdm.RoleAttachment ' + \
11029            'attached_role_id: ' + repr(self.attached_role_id) + ' ' +\
11030            'composite_role_id: ' + repr(self.composite_role_id) + ' ' +\
11031            'id: ' + repr(self.id) + ' ' +\
11032            '>'
11033
11034    def to_dict(self):
11035        return {
11036            'attached_role_id': self.attached_role_id,
11037            'composite_role_id': self.composite_role_id,
11038            'id': self.id,
11039        }
11040
11041    @classmethod
11042    def from_dict(cls, d):
11043        return cls(
11044            attached_role_id=d.get('attached_role_id'),
11045            composite_role_id=d.get('composite_role_id'),
11046            id=d.get('id'),
11047        )
11048
11049
11050class RoleAttachmentCreateResponse:
11051    '''
11052     RoleAttachmentCreateResponse reports how the RoleAttachments were created in the system.
11053     
11054     Deprecated: use multi-role via AccountAttachments instead.
11055    '''
11056    __slots__ = [
11057        'meta',
11058        'rate_limit',
11059        'role_attachment',
11060    ]
11061
11062    def __init__(
11063        self,
11064        meta=None,
11065        rate_limit=None,
11066        role_attachment=None,
11067    ):
11068        self.meta = meta if meta is not None else None
11069        '''
11070         Reserved for future use.
11071        '''
11072        self.rate_limit = rate_limit if rate_limit is not None else None
11073        '''
11074         Rate limit information.
11075        '''
11076        self.role_attachment = role_attachment if role_attachment is not None else None
11077        '''
11078         The created RoleAttachment.
11079        '''
11080
11081    def __repr__(self):
11082        return '<sdm.RoleAttachmentCreateResponse ' + \
11083            'meta: ' + repr(self.meta) + ' ' +\
11084            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
11085            'role_attachment: ' + repr(self.role_attachment) + ' ' +\
11086            '>'
11087
11088    def to_dict(self):
11089        return {
11090            'meta': self.meta,
11091            'rate_limit': self.rate_limit,
11092            'role_attachment': self.role_attachment,
11093        }
11094
11095    @classmethod
11096    def from_dict(cls, d):
11097        return cls(
11098            meta=d.get('meta'),
11099            rate_limit=d.get('rate_limit'),
11100            role_attachment=d.get('role_attachment'),
11101        )
11102
11103
11104class RoleAttachmentDeleteResponse:
11105    '''
11106     RoleAttachmentDeleteResponse returns information about a RoleAttachment that was deleted.
11107     
11108     Deprecated: use multi-role via AccountAttachments instead.
11109    '''
11110    __slots__ = [
11111        'meta',
11112        'rate_limit',
11113    ]
11114
11115    def __init__(
11116        self,
11117        meta=None,
11118        rate_limit=None,
11119    ):
11120        self.meta = meta if meta is not None else None
11121        '''
11122         Reserved for future use.
11123        '''
11124        self.rate_limit = rate_limit if rate_limit is not None else None
11125        '''
11126         Rate limit information.
11127        '''
11128
11129    def __repr__(self):
11130        return '<sdm.RoleAttachmentDeleteResponse ' + \
11131            'meta: ' + repr(self.meta) + ' ' +\
11132            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
11133            '>'
11134
11135    def to_dict(self):
11136        return {
11137            'meta': self.meta,
11138            'rate_limit': self.rate_limit,
11139        }
11140
11141    @classmethod
11142    def from_dict(cls, d):
11143        return cls(
11144            meta=d.get('meta'),
11145            rate_limit=d.get('rate_limit'),
11146        )
11147
11148
11149class RoleAttachmentGetResponse:
11150    '''
11151     RoleAttachmentGetResponse returns a requested RoleAttachment.
11152     
11153     Deprecated: use multi-role via AccountAttachments instead.
11154    '''
11155    __slots__ = [
11156        'meta',
11157        'rate_limit',
11158        'role_attachment',
11159    ]
11160
11161    def __init__(
11162        self,
11163        meta=None,
11164        rate_limit=None,
11165        role_attachment=None,
11166    ):
11167        self.meta = meta if meta is not None else None
11168        '''
11169         Reserved for future use.
11170        '''
11171        self.rate_limit = rate_limit if rate_limit is not None else None
11172        '''
11173         Rate limit information.
11174        '''
11175        self.role_attachment = role_attachment if role_attachment is not None else None
11176        '''
11177         The requested RoleAttachment.
11178        '''
11179
11180    def __repr__(self):
11181        return '<sdm.RoleAttachmentGetResponse ' + \
11182            'meta: ' + repr(self.meta) + ' ' +\
11183            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
11184            'role_attachment: ' + repr(self.role_attachment) + ' ' +\
11185            '>'
11186
11187    def to_dict(self):
11188        return {
11189            'meta': self.meta,
11190            'rate_limit': self.rate_limit,
11191            'role_attachment': self.role_attachment,
11192        }
11193
11194    @classmethod
11195    def from_dict(cls, d):
11196        return cls(
11197            meta=d.get('meta'),
11198            rate_limit=d.get('rate_limit'),
11199            role_attachment=d.get('role_attachment'),
11200        )
11201
11202
11203class RoleCreateResponse:
11204    '''
11205     RoleCreateResponse reports how the Roles were created in the system. It can
11206     communicate partial successes or failures.
11207    '''
11208    __slots__ = [
11209        'meta',
11210        'rate_limit',
11211        'role',
11212    ]
11213
11214    def __init__(
11215        self,
11216        meta=None,
11217        rate_limit=None,
11218        role=None,
11219    ):
11220        self.meta = meta if meta is not None else None
11221        '''
11222         Reserved for future use.
11223        '''
11224        self.rate_limit = rate_limit if rate_limit is not None else None
11225        '''
11226         Rate limit information.
11227        '''
11228        self.role = role if role is not None else None
11229        '''
11230         The created Role.
11231        '''
11232
11233    def __repr__(self):
11234        return '<sdm.RoleCreateResponse ' + \
11235            'meta: ' + repr(self.meta) + ' ' +\
11236            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
11237            'role: ' + repr(self.role) + ' ' +\
11238            '>'
11239
11240    def to_dict(self):
11241        return {
11242            'meta': self.meta,
11243            'rate_limit': self.rate_limit,
11244            'role': self.role,
11245        }
11246
11247    @classmethod
11248    def from_dict(cls, d):
11249        return cls(
11250            meta=d.get('meta'),
11251            rate_limit=d.get('rate_limit'),
11252            role=d.get('role'),
11253        )
11254
11255
11256class RoleDeleteResponse:
11257    '''
11258     RoleDeleteResponse returns information about a Role that was deleted.
11259    '''
11260    __slots__ = [
11261        'meta',
11262        'rate_limit',
11263    ]
11264
11265    def __init__(
11266        self,
11267        meta=None,
11268        rate_limit=None,
11269    ):
11270        self.meta = meta if meta is not None else None
11271        '''
11272         Reserved for future use.
11273        '''
11274        self.rate_limit = rate_limit if rate_limit is not None else None
11275        '''
11276         Rate limit information.
11277        '''
11278
11279    def __repr__(self):
11280        return '<sdm.RoleDeleteResponse ' + \
11281            'meta: ' + repr(self.meta) + ' ' +\
11282            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
11283            '>'
11284
11285    def to_dict(self):
11286        return {
11287            'meta': self.meta,
11288            'rate_limit': self.rate_limit,
11289        }
11290
11291    @classmethod
11292    def from_dict(cls, d):
11293        return cls(
11294            meta=d.get('meta'),
11295            rate_limit=d.get('rate_limit'),
11296        )
11297
11298
11299class RoleGetResponse:
11300    '''
11301     RoleGetResponse returns a requested Role.
11302    '''
11303    __slots__ = [
11304        'meta',
11305        'rate_limit',
11306        'role',
11307    ]
11308
11309    def __init__(
11310        self,
11311        meta=None,
11312        rate_limit=None,
11313        role=None,
11314    ):
11315        self.meta = meta if meta is not None else None
11316        '''
11317         Reserved for future use.
11318        '''
11319        self.rate_limit = rate_limit if rate_limit is not None else None
11320        '''
11321         Rate limit information.
11322        '''
11323        self.role = role if role is not None else None
11324        '''
11325         The requested Role.
11326        '''
11327
11328    def __repr__(self):
11329        return '<sdm.RoleGetResponse ' + \
11330            'meta: ' + repr(self.meta) + ' ' +\
11331            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
11332            'role: ' + repr(self.role) + ' ' +\
11333            '>'
11334
11335    def to_dict(self):
11336        return {
11337            'meta': self.meta,
11338            'rate_limit': self.rate_limit,
11339            'role': self.role,
11340        }
11341
11342    @classmethod
11343    def from_dict(cls, d):
11344        return cls(
11345            meta=d.get('meta'),
11346            rate_limit=d.get('rate_limit'),
11347            role=d.get('role'),
11348        )
11349
11350
11351class RoleGrant:
11352    '''
11353     A RoleGrant connects a resource to a role, granting members of the role access to that resource.
11354     
11355     Deprecated: use Role access rules instead.
11356    '''
11357    __slots__ = [
11358        'id',
11359        'resource_id',
11360        'role_id',
11361    ]
11362
11363    def __init__(
11364        self,
11365        id=None,
11366        resource_id=None,
11367        role_id=None,
11368    ):
11369        self.id = id if id is not None else ''
11370        '''
11371         Unique identifier of the RoleGrant.
11372        '''
11373        self.resource_id = resource_id if resource_id is not None else ''
11374        '''
11375         The id of the resource of this RoleGrant.
11376        '''
11377        self.role_id = role_id if role_id is not None else ''
11378        '''
11379         The id of the attached role of this RoleGrant.
11380        '''
11381
11382    def __repr__(self):
11383        return '<sdm.RoleGrant ' + \
11384            'id: ' + repr(self.id) + ' ' +\
11385            'resource_id: ' + repr(self.resource_id) + ' ' +\
11386            'role_id: ' + repr(self.role_id) + ' ' +\
11387            '>'
11388
11389    def to_dict(self):
11390        return {
11391            'id': self.id,
11392            'resource_id': self.resource_id,
11393            'role_id': self.role_id,
11394        }
11395
11396    @classmethod
11397    def from_dict(cls, d):
11398        return cls(
11399            id=d.get('id'),
11400            resource_id=d.get('resource_id'),
11401            role_id=d.get('role_id'),
11402        )
11403
11404
11405class RoleGrantCreateResponse:
11406    '''
11407     RoleGrantCreateResponse reports how the RoleGrants were created in the system.
11408     
11409     Deprecated: use Role access rules instead.
11410    '''
11411    __slots__ = [
11412        'meta',
11413        'rate_limit',
11414        'role_grant',
11415    ]
11416
11417    def __init__(
11418        self,
11419        meta=None,
11420        rate_limit=None,
11421        role_grant=None,
11422    ):
11423        self.meta = meta if meta is not None else None
11424        '''
11425         Reserved for future use.
11426        '''
11427        self.rate_limit = rate_limit if rate_limit is not None else None
11428        '''
11429         Rate limit information.
11430        '''
11431        self.role_grant = role_grant if role_grant is not None else None
11432        '''
11433         The created RoleGrant.
11434        '''
11435
11436    def __repr__(self):
11437        return '<sdm.RoleGrantCreateResponse ' + \
11438            'meta: ' + repr(self.meta) + ' ' +\
11439            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
11440            'role_grant: ' + repr(self.role_grant) + ' ' +\
11441            '>'
11442
11443    def to_dict(self):
11444        return {
11445            'meta': self.meta,
11446            'rate_limit': self.rate_limit,
11447            'role_grant': self.role_grant,
11448        }
11449
11450    @classmethod
11451    def from_dict(cls, d):
11452        return cls(
11453            meta=d.get('meta'),
11454            rate_limit=d.get('rate_limit'),
11455            role_grant=d.get('role_grant'),
11456        )
11457
11458
11459class RoleGrantDeleteResponse:
11460    '''
11461     RoleGrantDeleteResponse returns information about a RoleGrant that was deleted.
11462     
11463     Deprecated: use Role access rules instead.
11464    '''
11465    __slots__ = [
11466        'meta',
11467        'rate_limit',
11468    ]
11469
11470    def __init__(
11471        self,
11472        meta=None,
11473        rate_limit=None,
11474    ):
11475        self.meta = meta if meta is not None else None
11476        '''
11477         Reserved for future use.
11478        '''
11479        self.rate_limit = rate_limit if rate_limit is not None else None
11480        '''
11481         Rate limit information.
11482        '''
11483
11484    def __repr__(self):
11485        return '<sdm.RoleGrantDeleteResponse ' + \
11486            'meta: ' + repr(self.meta) + ' ' +\
11487            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
11488            '>'
11489
11490    def to_dict(self):
11491        return {
11492            'meta': self.meta,
11493            'rate_limit': self.rate_limit,
11494        }
11495
11496    @classmethod
11497    def from_dict(cls, d):
11498        return cls(
11499            meta=d.get('meta'),
11500            rate_limit=d.get('rate_limit'),
11501        )
11502
11503
11504class RoleGrantGetResponse:
11505    '''
11506     RoleGrantGetResponse returns a requested RoleGrant.
11507     
11508     Deprecated: use Role access rules instead.
11509    '''
11510    __slots__ = [
11511        'meta',
11512        'rate_limit',
11513        'role_grant',
11514    ]
11515
11516    def __init__(
11517        self,
11518        meta=None,
11519        rate_limit=None,
11520        role_grant=None,
11521    ):
11522        self.meta = meta if meta is not None else None
11523        '''
11524         Reserved for future use.
11525        '''
11526        self.rate_limit = rate_limit if rate_limit is not None else None
11527        '''
11528         Rate limit information.
11529        '''
11530        self.role_grant = role_grant if role_grant is not None else None
11531        '''
11532         The requested RoleGrant.
11533        '''
11534
11535    def __repr__(self):
11536        return '<sdm.RoleGrantGetResponse ' + \
11537            'meta: ' + repr(self.meta) + ' ' +\
11538            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
11539            'role_grant: ' + repr(self.role_grant) + ' ' +\
11540            '>'
11541
11542    def to_dict(self):
11543        return {
11544            'meta': self.meta,
11545            'rate_limit': self.rate_limit,
11546            'role_grant': self.role_grant,
11547        }
11548
11549    @classmethod
11550    def from_dict(cls, d):
11551        return cls(
11552            meta=d.get('meta'),
11553            rate_limit=d.get('rate_limit'),
11554            role_grant=d.get('role_grant'),
11555        )
11556
11557
11558class RoleUpdateResponse:
11559    '''
11560     RoleUpdateResponse returns the fields of a Role after it has been updated by
11561     a RoleUpdateRequest.
11562    '''
11563    __slots__ = [
11564        'meta',
11565        'rate_limit',
11566        'role',
11567    ]
11568
11569    def __init__(
11570        self,
11571        meta=None,
11572        rate_limit=None,
11573        role=None,
11574    ):
11575        self.meta = meta if meta is not None else None
11576        '''
11577         Reserved for future use.
11578        '''
11579        self.rate_limit = rate_limit if rate_limit is not None else None
11580        '''
11581         Rate limit information.
11582        '''
11583        self.role = role if role is not None else None
11584        '''
11585         The updated Role.
11586        '''
11587
11588    def __repr__(self):
11589        return '<sdm.RoleUpdateResponse ' + \
11590            'meta: ' + repr(self.meta) + ' ' +\
11591            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
11592            'role: ' + repr(self.role) + ' ' +\
11593            '>'
11594
11595    def to_dict(self):
11596        return {
11597            'meta': self.meta,
11598            'rate_limit': self.rate_limit,
11599            'role': self.role,
11600        }
11601
11602    @classmethod
11603    def from_dict(cls, d):
11604        return cls(
11605            meta=d.get('meta'),
11606            rate_limit=d.get('rate_limit'),
11607            role=d.get('role'),
11608        )
11609
11610
11611class SQLServer:
11612    '''
11613
11614    '''
11615    __slots__ = [
11616        'bind_interface',
11617        'database',
11618        'egress_filter',
11619        'healthy',
11620        'hostname',
11621        'id',
11622        'name',
11623        'override_database',
11624        'password',
11625        'port',
11626        'port_override',
11627        'schema',
11628        'secret_store_id',
11629        'tags',
11630        'username',
11631    ]
11632
11633    def __init__(
11634        self,
11635        bind_interface=None,
11636        database=None,
11637        egress_filter=None,
11638        healthy=None,
11639        hostname=None,
11640        id=None,
11641        name=None,
11642        override_database=None,
11643        password=None,
11644        port=None,
11645        port_override=None,
11646        schema=None,
11647        secret_store_id=None,
11648        tags=None,
11649        username=None,
11650    ):
11651        self.bind_interface = bind_interface if bind_interface is not None else ''
11652        '''
11653         Bind interface
11654        '''
11655        self.database = database if database is not None else ''
11656        '''
11657
11658        '''
11659        self.egress_filter = egress_filter if egress_filter is not None else ''
11660        '''
11661         A filter applied to the routing logic to pin datasource to nodes.
11662        '''
11663        self.healthy = healthy if healthy is not None else False
11664        '''
11665         True if the datasource is reachable and the credentials are valid.
11666        '''
11667        self.hostname = hostname if hostname is not None else ''
11668        '''
11669
11670        '''
11671        self.id = id if id is not None else ''
11672        '''
11673         Unique identifier of the Resource.
11674        '''
11675        self.name = name if name is not None else ''
11676        '''
11677         Unique human-readable name of the Resource.
11678        '''
11679        self.override_database = override_database if override_database is not None else False
11680        '''
11681
11682        '''
11683        self.password = password if password is not None else ''
11684        '''
11685
11686        '''
11687        self.port = port if port is not None else 0
11688        '''
11689
11690        '''
11691        self.port_override = port_override if port_override is not None else 0
11692        '''
11693
11694        '''
11695        self.schema = schema if schema is not None else ''
11696        '''
11697
11698        '''
11699        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11700        '''
11701         ID of the secret store containing credentials for this resource, if any.
11702        '''
11703        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11704        '''
11705         Tags is a map of key, value pairs.
11706        '''
11707        self.username = username if username is not None else ''
11708        '''
11709
11710        '''
11711
11712    def __repr__(self):
11713        return '<sdm.SQLServer ' + \
11714            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
11715            'database: ' + repr(self.database) + ' ' +\
11716            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
11717            'healthy: ' + repr(self.healthy) + ' ' +\
11718            'hostname: ' + repr(self.hostname) + ' ' +\
11719            'id: ' + repr(self.id) + ' ' +\
11720            'name: ' + repr(self.name) + ' ' +\
11721            'override_database: ' + repr(self.override_database) + ' ' +\
11722            'password: ' + repr(self.password) + ' ' +\
11723            'port: ' + repr(self.port) + ' ' +\
11724            'port_override: ' + repr(self.port_override) + ' ' +\
11725            'schema: ' + repr(self.schema) + ' ' +\
11726            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
11727            'tags: ' + repr(self.tags) + ' ' +\
11728            'username: ' + repr(self.username) + ' ' +\
11729            '>'
11730
11731    def to_dict(self):
11732        return {
11733            'bind_interface': self.bind_interface,
11734            'database': self.database,
11735            'egress_filter': self.egress_filter,
11736            'healthy': self.healthy,
11737            'hostname': self.hostname,
11738            'id': self.id,
11739            'name': self.name,
11740            'override_database': self.override_database,
11741            'password': self.password,
11742            'port': self.port,
11743            'port_override': self.port_override,
11744            'schema': self.schema,
11745            'secret_store_id': self.secret_store_id,
11746            'tags': self.tags,
11747            'username': self.username,
11748        }
11749
11750    @classmethod
11751    def from_dict(cls, d):
11752        return cls(
11753            bind_interface=d.get('bind_interface'),
11754            database=d.get('database'),
11755            egress_filter=d.get('egress_filter'),
11756            healthy=d.get('healthy'),
11757            hostname=d.get('hostname'),
11758            id=d.get('id'),
11759            name=d.get('name'),
11760            override_database=d.get('override_database'),
11761            password=d.get('password'),
11762            port=d.get('port'),
11763            port_override=d.get('port_override'),
11764            schema=d.get('schema'),
11765            secret_store_id=d.get('secret_store_id'),
11766            tags=d.get('tags'),
11767            username=d.get('username'),
11768        )
11769
11770
11771class SSH:
11772    '''
11773
11774    '''
11775    __slots__ = [
11776        'allow_deprecated_key_exchanges',
11777        'bind_interface',
11778        'egress_filter',
11779        'healthy',
11780        'hostname',
11781        'id',
11782        'name',
11783        'port',
11784        'port_forwarding',
11785        'port_override',
11786        'public_key',
11787        'secret_store_id',
11788        'tags',
11789        'username',
11790    ]
11791
11792    def __init__(
11793        self,
11794        allow_deprecated_key_exchanges=None,
11795        bind_interface=None,
11796        egress_filter=None,
11797        healthy=None,
11798        hostname=None,
11799        id=None,
11800        name=None,
11801        port=None,
11802        port_forwarding=None,
11803        port_override=None,
11804        public_key=None,
11805        secret_store_id=None,
11806        tags=None,
11807        username=None,
11808    ):
11809        self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges if allow_deprecated_key_exchanges is not None else False
11810        '''
11811
11812        '''
11813        self.bind_interface = bind_interface if bind_interface is not None else ''
11814        '''
11815         Bind interface
11816        '''
11817        self.egress_filter = egress_filter if egress_filter is not None else ''
11818        '''
11819         A filter applied to the routing logic to pin datasource to nodes.
11820        '''
11821        self.healthy = healthy if healthy is not None else False
11822        '''
11823         True if the datasource is reachable and the credentials are valid.
11824        '''
11825        self.hostname = hostname if hostname is not None else ''
11826        '''
11827
11828        '''
11829        self.id = id if id is not None else ''
11830        '''
11831         Unique identifier of the Resource.
11832        '''
11833        self.name = name if name is not None else ''
11834        '''
11835         Unique human-readable name of the Resource.
11836        '''
11837        self.port = port if port is not None else 0
11838        '''
11839
11840        '''
11841        self.port_forwarding = port_forwarding if port_forwarding is not None else False
11842        '''
11843
11844        '''
11845        self.port_override = port_override if port_override is not None else 0
11846        '''
11847
11848        '''
11849        self.public_key = public_key if public_key is not None else ''
11850        '''
11851
11852        '''
11853        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11854        '''
11855         ID of the secret store containing credentials for this resource, if any.
11856        '''
11857        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11858        '''
11859         Tags is a map of key, value pairs.
11860        '''
11861        self.username = username if username is not None else ''
11862        '''
11863
11864        '''
11865
11866    def __repr__(self):
11867        return '<sdm.SSH ' + \
11868            'allow_deprecated_key_exchanges: ' + repr(self.allow_deprecated_key_exchanges) + ' ' +\
11869            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
11870            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
11871            'healthy: ' + repr(self.healthy) + ' ' +\
11872            'hostname: ' + repr(self.hostname) + ' ' +\
11873            'id: ' + repr(self.id) + ' ' +\
11874            'name: ' + repr(self.name) + ' ' +\
11875            'port: ' + repr(self.port) + ' ' +\
11876            'port_forwarding: ' + repr(self.port_forwarding) + ' ' +\
11877            'port_override: ' + repr(self.port_override) + ' ' +\
11878            'public_key: ' + repr(self.public_key) + ' ' +\
11879            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
11880            'tags: ' + repr(self.tags) + ' ' +\
11881            'username: ' + repr(self.username) + ' ' +\
11882            '>'
11883
11884    def to_dict(self):
11885        return {
11886            'allow_deprecated_key_exchanges':
11887            self.allow_deprecated_key_exchanges,
11888            'bind_interface': self.bind_interface,
11889            'egress_filter': self.egress_filter,
11890            'healthy': self.healthy,
11891            'hostname': self.hostname,
11892            'id': self.id,
11893            'name': self.name,
11894            'port': self.port,
11895            'port_forwarding': self.port_forwarding,
11896            'port_override': self.port_override,
11897            'public_key': self.public_key,
11898            'secret_store_id': self.secret_store_id,
11899            'tags': self.tags,
11900            'username': self.username,
11901        }
11902
11903    @classmethod
11904    def from_dict(cls, d):
11905        return cls(
11906            allow_deprecated_key_exchanges=d.get(
11907                'allow_deprecated_key_exchanges'),
11908            bind_interface=d.get('bind_interface'),
11909            egress_filter=d.get('egress_filter'),
11910            healthy=d.get('healthy'),
11911            hostname=d.get('hostname'),
11912            id=d.get('id'),
11913            name=d.get('name'),
11914            port=d.get('port'),
11915            port_forwarding=d.get('port_forwarding'),
11916            port_override=d.get('port_override'),
11917            public_key=d.get('public_key'),
11918            secret_store_id=d.get('secret_store_id'),
11919            tags=d.get('tags'),
11920            username=d.get('username'),
11921        )
11922
11923
11924class SSHCert:
11925    '''
11926
11927    '''
11928    __slots__ = [
11929        'allow_deprecated_key_exchanges',
11930        'bind_interface',
11931        'egress_filter',
11932        'healthy',
11933        'hostname',
11934        'id',
11935        'name',
11936        'port',
11937        'port_forwarding',
11938        'port_override',
11939        'remote_identity_group_id',
11940        'remote_identity_healthcheck_username',
11941        'secret_store_id',
11942        'tags',
11943        'username',
11944    ]
11945
11946    def __init__(
11947        self,
11948        allow_deprecated_key_exchanges=None,
11949        bind_interface=None,
11950        egress_filter=None,
11951        healthy=None,
11952        hostname=None,
11953        id=None,
11954        name=None,
11955        port=None,
11956        port_forwarding=None,
11957        port_override=None,
11958        remote_identity_group_id=None,
11959        remote_identity_healthcheck_username=None,
11960        secret_store_id=None,
11961        tags=None,
11962        username=None,
11963    ):
11964        self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges if allow_deprecated_key_exchanges is not None else False
11965        '''
11966
11967        '''
11968        self.bind_interface = bind_interface if bind_interface is not None else ''
11969        '''
11970         Bind interface
11971        '''
11972        self.egress_filter = egress_filter if egress_filter is not None else ''
11973        '''
11974         A filter applied to the routing logic to pin datasource to nodes.
11975        '''
11976        self.healthy = healthy if healthy is not None else False
11977        '''
11978         True if the datasource is reachable and the credentials are valid.
11979        '''
11980        self.hostname = hostname if hostname is not None else ''
11981        '''
11982
11983        '''
11984        self.id = id if id is not None else ''
11985        '''
11986         Unique identifier of the Resource.
11987        '''
11988        self.name = name if name is not None else ''
11989        '''
11990         Unique human-readable name of the Resource.
11991        '''
11992        self.port = port if port is not None else 0
11993        '''
11994
11995        '''
11996        self.port_forwarding = port_forwarding if port_forwarding is not None else False
11997        '''
11998
11999        '''
12000        self.port_override = port_override if port_override is not None else 0
12001        '''
12002
12003        '''
12004        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
12005        '''
12006
12007        '''
12008        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
12009        '''
12010
12011        '''
12012        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
12013        '''
12014         ID of the secret store containing credentials for this resource, if any.
12015        '''
12016        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12017        '''
12018         Tags is a map of key, value pairs.
12019        '''
12020        self.username = username if username is not None else ''
12021        '''
12022
12023        '''
12024
12025    def __repr__(self):
12026        return '<sdm.SSHCert ' + \
12027            'allow_deprecated_key_exchanges: ' + repr(self.allow_deprecated_key_exchanges) + ' ' +\
12028            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
12029            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
12030            'healthy: ' + repr(self.healthy) + ' ' +\
12031            'hostname: ' + repr(self.hostname) + ' ' +\
12032            'id: ' + repr(self.id) + ' ' +\
12033            'name: ' + repr(self.name) + ' ' +\
12034            'port: ' + repr(self.port) + ' ' +\
12035            'port_forwarding: ' + repr(self.port_forwarding) + ' ' +\
12036            'port_override: ' + repr(self.port_override) + ' ' +\
12037            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
12038            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
12039            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
12040            'tags: ' + repr(self.tags) + ' ' +\
12041            'username: ' + repr(self.username) + ' ' +\
12042            '>'
12043
12044    def to_dict(self):
12045        return {
12046            'allow_deprecated_key_exchanges':
12047            self.allow_deprecated_key_exchanges,
12048            'bind_interface': self.bind_interface,
12049            'egress_filter': self.egress_filter,
12050            'healthy': self.healthy,
12051            'hostname': self.hostname,
12052            'id': self.id,
12053            'name': self.name,
12054            'port': self.port,
12055            'port_forwarding': self.port_forwarding,
12056            'port_override': self.port_override,
12057            'remote_identity_group_id': self.remote_identity_group_id,
12058            'remote_identity_healthcheck_username':
12059            self.remote_identity_healthcheck_username,
12060            'secret_store_id': self.secret_store_id,
12061            'tags': self.tags,
12062            'username': self.username,
12063        }
12064
12065    @classmethod
12066    def from_dict(cls, d):
12067        return cls(
12068            allow_deprecated_key_exchanges=d.get(
12069                'allow_deprecated_key_exchanges'),
12070            bind_interface=d.get('bind_interface'),
12071            egress_filter=d.get('egress_filter'),
12072            healthy=d.get('healthy'),
12073            hostname=d.get('hostname'),
12074            id=d.get('id'),
12075            name=d.get('name'),
12076            port=d.get('port'),
12077            port_forwarding=d.get('port_forwarding'),
12078            port_override=d.get('port_override'),
12079            remote_identity_group_id=d.get('remote_identity_group_id'),
12080            remote_identity_healthcheck_username=d.get(
12081                'remote_identity_healthcheck_username'),
12082            secret_store_id=d.get('secret_store_id'),
12083            tags=d.get('tags'),
12084            username=d.get('username'),
12085        )
12086
12087
12088class SSHCustomerKey:
12089    '''
12090
12091    '''
12092    __slots__ = [
12093        'allow_deprecated_key_exchanges',
12094        'bind_interface',
12095        'egress_filter',
12096        'healthy',
12097        'hostname',
12098        'id',
12099        'name',
12100        'port',
12101        'port_forwarding',
12102        'port_override',
12103        'private_key',
12104        'secret_store_id',
12105        'tags',
12106        'username',
12107    ]
12108
12109    def __init__(
12110        self,
12111        allow_deprecated_key_exchanges=None,
12112        bind_interface=None,
12113        egress_filter=None,
12114        healthy=None,
12115        hostname=None,
12116        id=None,
12117        name=None,
12118        port=None,
12119        port_forwarding=None,
12120        port_override=None,
12121        private_key=None,
12122        secret_store_id=None,
12123        tags=None,
12124        username=None,
12125    ):
12126        self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges if allow_deprecated_key_exchanges is not None else False
12127        '''
12128
12129        '''
12130        self.bind_interface = bind_interface if bind_interface is not None else ''
12131        '''
12132         Bind interface
12133        '''
12134        self.egress_filter = egress_filter if egress_filter is not None else ''
12135        '''
12136         A filter applied to the routing logic to pin datasource to nodes.
12137        '''
12138        self.healthy = healthy if healthy is not None else False
12139        '''
12140         True if the datasource is reachable and the credentials are valid.
12141        '''
12142        self.hostname = hostname if hostname is not None else ''
12143        '''
12144
12145        '''
12146        self.id = id if id is not None else ''
12147        '''
12148         Unique identifier of the Resource.
12149        '''
12150        self.name = name if name is not None else ''
12151        '''
12152         Unique human-readable name of the Resource.
12153        '''
12154        self.port = port if port is not None else 0
12155        '''
12156
12157        '''
12158        self.port_forwarding = port_forwarding if port_forwarding is not None else False
12159        '''
12160
12161        '''
12162        self.port_override = port_override if port_override is not None else 0
12163        '''
12164
12165        '''
12166        self.private_key = private_key if private_key is not None else ''
12167        '''
12168
12169        '''
12170        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
12171        '''
12172         ID of the secret store containing credentials for this resource, if any.
12173        '''
12174        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12175        '''
12176         Tags is a map of key, value pairs.
12177        '''
12178        self.username = username if username is not None else ''
12179        '''
12180
12181        '''
12182
12183    def __repr__(self):
12184        return '<sdm.SSHCustomerKey ' + \
12185            'allow_deprecated_key_exchanges: ' + repr(self.allow_deprecated_key_exchanges) + ' ' +\
12186            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
12187            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
12188            'healthy: ' + repr(self.healthy) + ' ' +\
12189            'hostname: ' + repr(self.hostname) + ' ' +\
12190            'id: ' + repr(self.id) + ' ' +\
12191            'name: ' + repr(self.name) + ' ' +\
12192            'port: ' + repr(self.port) + ' ' +\
12193            'port_forwarding: ' + repr(self.port_forwarding) + ' ' +\
12194            'port_override: ' + repr(self.port_override) + ' ' +\
12195            'private_key: ' + repr(self.private_key) + ' ' +\
12196            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
12197            'tags: ' + repr(self.tags) + ' ' +\
12198            'username: ' + repr(self.username) + ' ' +\
12199            '>'
12200
12201    def to_dict(self):
12202        return {
12203            'allow_deprecated_key_exchanges':
12204            self.allow_deprecated_key_exchanges,
12205            'bind_interface': self.bind_interface,
12206            'egress_filter': self.egress_filter,
12207            'healthy': self.healthy,
12208            'hostname': self.hostname,
12209            'id': self.id,
12210            'name': self.name,
12211            'port': self.port,
12212            'port_forwarding': self.port_forwarding,
12213            'port_override': self.port_override,
12214            'private_key': self.private_key,
12215            'secret_store_id': self.secret_store_id,
12216            'tags': self.tags,
12217            'username': self.username,
12218        }
12219
12220    @classmethod
12221    def from_dict(cls, d):
12222        return cls(
12223            allow_deprecated_key_exchanges=d.get(
12224                'allow_deprecated_key_exchanges'),
12225            bind_interface=d.get('bind_interface'),
12226            egress_filter=d.get('egress_filter'),
12227            healthy=d.get('healthy'),
12228            hostname=d.get('hostname'),
12229            id=d.get('id'),
12230            name=d.get('name'),
12231            port=d.get('port'),
12232            port_forwarding=d.get('port_forwarding'),
12233            port_override=d.get('port_override'),
12234            private_key=d.get('private_key'),
12235            secret_store_id=d.get('secret_store_id'),
12236            tags=d.get('tags'),
12237            username=d.get('username'),
12238        )
12239
12240
12241class SecretStoreCreateResponse:
12242    '''
12243     SecretStoreCreateResponse reports how the SecretStores were created in the system.
12244    '''
12245    __slots__ = [
12246        'meta',
12247        'rate_limit',
12248        'secret_store',
12249    ]
12250
12251    def __init__(
12252        self,
12253        meta=None,
12254        rate_limit=None,
12255        secret_store=None,
12256    ):
12257        self.meta = meta if meta is not None else None
12258        '''
12259         Reserved for future use.
12260        '''
12261        self.rate_limit = rate_limit if rate_limit is not None else None
12262        '''
12263         Rate limit information.
12264        '''
12265        self.secret_store = secret_store if secret_store is not None else None
12266        '''
12267         The created SecretStore.
12268        '''
12269
12270    def __repr__(self):
12271        return '<sdm.SecretStoreCreateResponse ' + \
12272            'meta: ' + repr(self.meta) + ' ' +\
12273            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
12274            'secret_store: ' + repr(self.secret_store) + ' ' +\
12275            '>'
12276
12277    def to_dict(self):
12278        return {
12279            'meta': self.meta,
12280            'rate_limit': self.rate_limit,
12281            'secret_store': self.secret_store,
12282        }
12283
12284    @classmethod
12285    def from_dict(cls, d):
12286        return cls(
12287            meta=d.get('meta'),
12288            rate_limit=d.get('rate_limit'),
12289            secret_store=d.get('secret_store'),
12290        )
12291
12292
12293class SecretStoreDeleteResponse:
12294    '''
12295     SecretStoreDeleteResponse returns information about a SecretStore that was deleted.
12296    '''
12297    __slots__ = [
12298        'meta',
12299        'rate_limit',
12300    ]
12301
12302    def __init__(
12303        self,
12304        meta=None,
12305        rate_limit=None,
12306    ):
12307        self.meta = meta if meta is not None else None
12308        '''
12309         Reserved for future use.
12310        '''
12311        self.rate_limit = rate_limit if rate_limit is not None else None
12312        '''
12313         Rate limit information.
12314        '''
12315
12316    def __repr__(self):
12317        return '<sdm.SecretStoreDeleteResponse ' + \
12318            'meta: ' + repr(self.meta) + ' ' +\
12319            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
12320            '>'
12321
12322    def to_dict(self):
12323        return {
12324            'meta': self.meta,
12325            'rate_limit': self.rate_limit,
12326        }
12327
12328    @classmethod
12329    def from_dict(cls, d):
12330        return cls(
12331            meta=d.get('meta'),
12332            rate_limit=d.get('rate_limit'),
12333        )
12334
12335
12336class SecretStoreGetResponse:
12337    '''
12338     SecretStoreGetResponse returns a requested SecretStore.
12339    '''
12340    __slots__ = [
12341        'meta',
12342        'rate_limit',
12343        'secret_store',
12344    ]
12345
12346    def __init__(
12347        self,
12348        meta=None,
12349        rate_limit=None,
12350        secret_store=None,
12351    ):
12352        self.meta = meta if meta is not None else None
12353        '''
12354         Reserved for future use.
12355        '''
12356        self.rate_limit = rate_limit if rate_limit is not None else None
12357        '''
12358         Rate limit information.
12359        '''
12360        self.secret_store = secret_store if secret_store is not None else None
12361        '''
12362         The requested SecretStore.
12363        '''
12364
12365    def __repr__(self):
12366        return '<sdm.SecretStoreGetResponse ' + \
12367            'meta: ' + repr(self.meta) + ' ' +\
12368            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
12369            'secret_store: ' + repr(self.secret_store) + ' ' +\
12370            '>'
12371
12372    def to_dict(self):
12373        return {
12374            'meta': self.meta,
12375            'rate_limit': self.rate_limit,
12376            'secret_store': self.secret_store,
12377        }
12378
12379    @classmethod
12380    def from_dict(cls, d):
12381        return cls(
12382            meta=d.get('meta'),
12383            rate_limit=d.get('rate_limit'),
12384            secret_store=d.get('secret_store'),
12385        )
12386
12387
12388class SecretStoreUpdateResponse:
12389    '''
12390     SecretStoreUpdateResponse returns the fields of a SecretStore after it has been updated by
12391     a SecretStoreUpdateRequest.
12392    '''
12393    __slots__ = [
12394        'meta',
12395        'rate_limit',
12396        'secret_store',
12397    ]
12398
12399    def __init__(
12400        self,
12401        meta=None,
12402        rate_limit=None,
12403        secret_store=None,
12404    ):
12405        self.meta = meta if meta is not None else None
12406        '''
12407         Reserved for future use.
12408        '''
12409        self.rate_limit = rate_limit if rate_limit is not None else None
12410        '''
12411         Rate limit information.
12412        '''
12413        self.secret_store = secret_store if secret_store is not None else None
12414        '''
12415         The updated SecretStore.
12416        '''
12417
12418    def __repr__(self):
12419        return '<sdm.SecretStoreUpdateResponse ' + \
12420            'meta: ' + repr(self.meta) + ' ' +\
12421            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
12422            'secret_store: ' + repr(self.secret_store) + ' ' +\
12423            '>'
12424
12425    def to_dict(self):
12426        return {
12427            'meta': self.meta,
12428            'rate_limit': self.rate_limit,
12429            'secret_store': self.secret_store,
12430        }
12431
12432    @classmethod
12433    def from_dict(cls, d):
12434        return cls(
12435            meta=d.get('meta'),
12436            rate_limit=d.get('rate_limit'),
12437            secret_store=d.get('secret_store'),
12438        )
12439
12440
12441class Service:
12442    '''
12443     A Service is a service account that can connect to resources they are granted
12444     directly, or granted via roles. Services are typically automated jobs.
12445    '''
12446    __slots__ = [
12447        'id',
12448        'name',
12449        'suspended',
12450        'tags',
12451    ]
12452
12453    def __init__(
12454        self,
12455        id=None,
12456        name=None,
12457        suspended=None,
12458        tags=None,
12459    ):
12460        self.id = id if id is not None else ''
12461        '''
12462         Unique identifier of the Service.
12463        '''
12464        self.name = name if name is not None else ''
12465        '''
12466         Unique human-readable name of the Service.
12467        '''
12468        self.suspended = suspended if suspended is not None else False
12469        '''
12470         The Service's suspended state.
12471        '''
12472        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12473        '''
12474         Tags is a map of key, value pairs.
12475        '''
12476
12477    def __repr__(self):
12478        return '<sdm.Service ' + \
12479            'id: ' + repr(self.id) + ' ' +\
12480            'name: ' + repr(self.name) + ' ' +\
12481            'suspended: ' + repr(self.suspended) + ' ' +\
12482            'tags: ' + repr(self.tags) + ' ' +\
12483            '>'
12484
12485    def to_dict(self):
12486        return {
12487            'id': self.id,
12488            'name': self.name,
12489            'suspended': self.suspended,
12490            'tags': self.tags,
12491        }
12492
12493    @classmethod
12494    def from_dict(cls, d):
12495        return cls(
12496            id=d.get('id'),
12497            name=d.get('name'),
12498            suspended=d.get('suspended'),
12499            tags=d.get('tags'),
12500        )
12501
12502
12503class SingleStore:
12504    '''
12505
12506    '''
12507    __slots__ = [
12508        'bind_interface',
12509        'database',
12510        'egress_filter',
12511        'healthy',
12512        'hostname',
12513        'id',
12514        'name',
12515        'password',
12516        'port',
12517        'port_override',
12518        'secret_store_id',
12519        'tags',
12520        'username',
12521    ]
12522
12523    def __init__(
12524        self,
12525        bind_interface=None,
12526        database=None,
12527        egress_filter=None,
12528        healthy=None,
12529        hostname=None,
12530        id=None,
12531        name=None,
12532        password=None,
12533        port=None,
12534        port_override=None,
12535        secret_store_id=None,
12536        tags=None,
12537        username=None,
12538    ):
12539        self.bind_interface = bind_interface if bind_interface is not None else ''
12540        '''
12541         Bind interface
12542        '''
12543        self.database = database if database is not None else ''
12544        '''
12545
12546        '''
12547        self.egress_filter = egress_filter if egress_filter is not None else ''
12548        '''
12549         A filter applied to the routing logic to pin datasource to nodes.
12550        '''
12551        self.healthy = healthy if healthy is not None else False
12552        '''
12553         True if the datasource is reachable and the credentials are valid.
12554        '''
12555        self.hostname = hostname if hostname is not None else ''
12556        '''
12557
12558        '''
12559        self.id = id if id is not None else ''
12560        '''
12561         Unique identifier of the Resource.
12562        '''
12563        self.name = name if name is not None else ''
12564        '''
12565         Unique human-readable name of the Resource.
12566        '''
12567        self.password = password if password is not None else ''
12568        '''
12569
12570        '''
12571        self.port = port if port is not None else 0
12572        '''
12573
12574        '''
12575        self.port_override = port_override if port_override is not None else 0
12576        '''
12577
12578        '''
12579        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
12580        '''
12581         ID of the secret store containing credentials for this resource, if any.
12582        '''
12583        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12584        '''
12585         Tags is a map of key, value pairs.
12586        '''
12587        self.username = username if username is not None else ''
12588        '''
12589
12590        '''
12591
12592    def __repr__(self):
12593        return '<sdm.SingleStore ' + \
12594            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
12595            'database: ' + repr(self.database) + ' ' +\
12596            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
12597            'healthy: ' + repr(self.healthy) + ' ' +\
12598            'hostname: ' + repr(self.hostname) + ' ' +\
12599            'id: ' + repr(self.id) + ' ' +\
12600            'name: ' + repr(self.name) + ' ' +\
12601            'password: ' + repr(self.password) + ' ' +\
12602            'port: ' + repr(self.port) + ' ' +\
12603            'port_override: ' + repr(self.port_override) + ' ' +\
12604            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
12605            'tags: ' + repr(self.tags) + ' ' +\
12606            'username: ' + repr(self.username) + ' ' +\
12607            '>'
12608
12609    def to_dict(self):
12610        return {
12611            'bind_interface': self.bind_interface,
12612            'database': self.database,
12613            'egress_filter': self.egress_filter,
12614            'healthy': self.healthy,
12615            'hostname': self.hostname,
12616            'id': self.id,
12617            'name': self.name,
12618            'password': self.password,
12619            'port': self.port,
12620            'port_override': self.port_override,
12621            'secret_store_id': self.secret_store_id,
12622            'tags': self.tags,
12623            'username': self.username,
12624        }
12625
12626    @classmethod
12627    def from_dict(cls, d):
12628        return cls(
12629            bind_interface=d.get('bind_interface'),
12630            database=d.get('database'),
12631            egress_filter=d.get('egress_filter'),
12632            healthy=d.get('healthy'),
12633            hostname=d.get('hostname'),
12634            id=d.get('id'),
12635            name=d.get('name'),
12636            password=d.get('password'),
12637            port=d.get('port'),
12638            port_override=d.get('port_override'),
12639            secret_store_id=d.get('secret_store_id'),
12640            tags=d.get('tags'),
12641            username=d.get('username'),
12642        )
12643
12644
12645class Snowflake:
12646    '''
12647
12648    '''
12649    __slots__ = [
12650        'bind_interface',
12651        'database',
12652        'egress_filter',
12653        'healthy',
12654        'hostname',
12655        'id',
12656        'name',
12657        'password',
12658        'port_override',
12659        'schema',
12660        'secret_store_id',
12661        'tags',
12662        'username',
12663    ]
12664
12665    def __init__(
12666        self,
12667        bind_interface=None,
12668        database=None,
12669        egress_filter=None,
12670        healthy=None,
12671        hostname=None,
12672        id=None,
12673        name=None,
12674        password=None,
12675        port_override=None,
12676        schema=None,
12677        secret_store_id=None,
12678        tags=None,
12679        username=None,
12680    ):
12681        self.bind_interface = bind_interface if bind_interface is not None else ''
12682        '''
12683         Bind interface
12684        '''
12685        self.database = database if database is not None else ''
12686        '''
12687
12688        '''
12689        self.egress_filter = egress_filter if egress_filter is not None else ''
12690        '''
12691         A filter applied to the routing logic to pin datasource to nodes.
12692        '''
12693        self.healthy = healthy if healthy is not None else False
12694        '''
12695         True if the datasource is reachable and the credentials are valid.
12696        '''
12697        self.hostname = hostname if hostname is not None else ''
12698        '''
12699
12700        '''
12701        self.id = id if id is not None else ''
12702        '''
12703         Unique identifier of the Resource.
12704        '''
12705        self.name = name if name is not None else ''
12706        '''
12707         Unique human-readable name of the Resource.
12708        '''
12709        self.password = password if password is not None else ''
12710        '''
12711
12712        '''
12713        self.port_override = port_override if port_override is not None else 0
12714        '''
12715
12716        '''
12717        self.schema = schema if schema is not None else ''
12718        '''
12719
12720        '''
12721        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
12722        '''
12723         ID of the secret store containing credentials for this resource, if any.
12724        '''
12725        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12726        '''
12727         Tags is a map of key, value pairs.
12728        '''
12729        self.username = username if username is not None else ''
12730        '''
12731
12732        '''
12733
12734    def __repr__(self):
12735        return '<sdm.Snowflake ' + \
12736            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
12737            'database: ' + repr(self.database) + ' ' +\
12738            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
12739            'healthy: ' + repr(self.healthy) + ' ' +\
12740            'hostname: ' + repr(self.hostname) + ' ' +\
12741            'id: ' + repr(self.id) + ' ' +\
12742            'name: ' + repr(self.name) + ' ' +\
12743            'password: ' + repr(self.password) + ' ' +\
12744            'port_override: ' + repr(self.port_override) + ' ' +\
12745            'schema: ' + repr(self.schema) + ' ' +\
12746            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
12747            'tags: ' + repr(self.tags) + ' ' +\
12748            'username: ' + repr(self.username) + ' ' +\
12749            '>'
12750
12751    def to_dict(self):
12752        return {
12753            'bind_interface': self.bind_interface,
12754            'database': self.database,
12755            'egress_filter': self.egress_filter,
12756            'healthy': self.healthy,
12757            'hostname': self.hostname,
12758            'id': self.id,
12759            'name': self.name,
12760            'password': self.password,
12761            'port_override': self.port_override,
12762            'schema': self.schema,
12763            'secret_store_id': self.secret_store_id,
12764            'tags': self.tags,
12765            'username': self.username,
12766        }
12767
12768    @classmethod
12769    def from_dict(cls, d):
12770        return cls(
12771            bind_interface=d.get('bind_interface'),
12772            database=d.get('database'),
12773            egress_filter=d.get('egress_filter'),
12774            healthy=d.get('healthy'),
12775            hostname=d.get('hostname'),
12776            id=d.get('id'),
12777            name=d.get('name'),
12778            password=d.get('password'),
12779            port_override=d.get('port_override'),
12780            schema=d.get('schema'),
12781            secret_store_id=d.get('secret_store_id'),
12782            tags=d.get('tags'),
12783            username=d.get('username'),
12784        )
12785
12786
12787class Sybase:
12788    '''
12789
12790    '''
12791    __slots__ = [
12792        'bind_interface',
12793        'egress_filter',
12794        'healthy',
12795        'hostname',
12796        'id',
12797        'name',
12798        'password',
12799        'port',
12800        'port_override',
12801        'secret_store_id',
12802        'tags',
12803        'username',
12804    ]
12805
12806    def __init__(
12807        self,
12808        bind_interface=None,
12809        egress_filter=None,
12810        healthy=None,
12811        hostname=None,
12812        id=None,
12813        name=None,
12814        password=None,
12815        port=None,
12816        port_override=None,
12817        secret_store_id=None,
12818        tags=None,
12819        username=None,
12820    ):
12821        self.bind_interface = bind_interface if bind_interface is not None else ''
12822        '''
12823         Bind interface
12824        '''
12825        self.egress_filter = egress_filter if egress_filter is not None else ''
12826        '''
12827         A filter applied to the routing logic to pin datasource to nodes.
12828        '''
12829        self.healthy = healthy if healthy is not None else False
12830        '''
12831         True if the datasource is reachable and the credentials are valid.
12832        '''
12833        self.hostname = hostname if hostname is not None else ''
12834        '''
12835
12836        '''
12837        self.id = id if id is not None else ''
12838        '''
12839         Unique identifier of the Resource.
12840        '''
12841        self.name = name if name is not None else ''
12842        '''
12843         Unique human-readable name of the Resource.
12844        '''
12845        self.password = password if password is not None else ''
12846        '''
12847
12848        '''
12849        self.port = port if port is not None else 0
12850        '''
12851
12852        '''
12853        self.port_override = port_override if port_override is not None else 0
12854        '''
12855
12856        '''
12857        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
12858        '''
12859         ID of the secret store containing credentials for this resource, if any.
12860        '''
12861        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12862        '''
12863         Tags is a map of key, value pairs.
12864        '''
12865        self.username = username if username is not None else ''
12866        '''
12867
12868        '''
12869
12870    def __repr__(self):
12871        return '<sdm.Sybase ' + \
12872            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
12873            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
12874            'healthy: ' + repr(self.healthy) + ' ' +\
12875            'hostname: ' + repr(self.hostname) + ' ' +\
12876            'id: ' + repr(self.id) + ' ' +\
12877            'name: ' + repr(self.name) + ' ' +\
12878            'password: ' + repr(self.password) + ' ' +\
12879            'port: ' + repr(self.port) + ' ' +\
12880            'port_override: ' + repr(self.port_override) + ' ' +\
12881            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
12882            'tags: ' + repr(self.tags) + ' ' +\
12883            'username: ' + repr(self.username) + ' ' +\
12884            '>'
12885
12886    def to_dict(self):
12887        return {
12888            'bind_interface': self.bind_interface,
12889            'egress_filter': self.egress_filter,
12890            'healthy': self.healthy,
12891            'hostname': self.hostname,
12892            'id': self.id,
12893            'name': self.name,
12894            'password': self.password,
12895            'port': self.port,
12896            'port_override': self.port_override,
12897            'secret_store_id': self.secret_store_id,
12898            'tags': self.tags,
12899            'username': self.username,
12900        }
12901
12902    @classmethod
12903    def from_dict(cls, d):
12904        return cls(
12905            bind_interface=d.get('bind_interface'),
12906            egress_filter=d.get('egress_filter'),
12907            healthy=d.get('healthy'),
12908            hostname=d.get('hostname'),
12909            id=d.get('id'),
12910            name=d.get('name'),
12911            password=d.get('password'),
12912            port=d.get('port'),
12913            port_override=d.get('port_override'),
12914            secret_store_id=d.get('secret_store_id'),
12915            tags=d.get('tags'),
12916            username=d.get('username'),
12917        )
12918
12919
12920class SybaseIQ:
12921    '''
12922
12923    '''
12924    __slots__ = [
12925        'bind_interface',
12926        'egress_filter',
12927        'healthy',
12928        'hostname',
12929        'id',
12930        'name',
12931        'password',
12932        'port',
12933        'port_override',
12934        'secret_store_id',
12935        'tags',
12936        'username',
12937    ]
12938
12939    def __init__(
12940        self,
12941        bind_interface=None,
12942        egress_filter=None,
12943        healthy=None,
12944        hostname=None,
12945        id=None,
12946        name=None,
12947        password=None,
12948        port=None,
12949        port_override=None,
12950        secret_store_id=None,
12951        tags=None,
12952        username=None,
12953    ):
12954        self.bind_interface = bind_interface if bind_interface is not None else ''
12955        '''
12956         Bind interface
12957        '''
12958        self.egress_filter = egress_filter if egress_filter is not None else ''
12959        '''
12960         A filter applied to the routing logic to pin datasource to nodes.
12961        '''
12962        self.healthy = healthy if healthy is not None else False
12963        '''
12964         True if the datasource is reachable and the credentials are valid.
12965        '''
12966        self.hostname = hostname if hostname is not None else ''
12967        '''
12968
12969        '''
12970        self.id = id if id is not None else ''
12971        '''
12972         Unique identifier of the Resource.
12973        '''
12974        self.name = name if name is not None else ''
12975        '''
12976         Unique human-readable name of the Resource.
12977        '''
12978        self.password = password if password is not None else ''
12979        '''
12980
12981        '''
12982        self.port = port if port is not None else 0
12983        '''
12984
12985        '''
12986        self.port_override = port_override if port_override is not None else 0
12987        '''
12988
12989        '''
12990        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
12991        '''
12992         ID of the secret store containing credentials for this resource, if any.
12993        '''
12994        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12995        '''
12996         Tags is a map of key, value pairs.
12997        '''
12998        self.username = username if username is not None else ''
12999        '''
13000
13001        '''
13002
13003    def __repr__(self):
13004        return '<sdm.SybaseIQ ' + \
13005            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
13006            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
13007            'healthy: ' + repr(self.healthy) + ' ' +\
13008            'hostname: ' + repr(self.hostname) + ' ' +\
13009            'id: ' + repr(self.id) + ' ' +\
13010            'name: ' + repr(self.name) + ' ' +\
13011            'password: ' + repr(self.password) + ' ' +\
13012            'port: ' + repr(self.port) + ' ' +\
13013            'port_override: ' + repr(self.port_override) + ' ' +\
13014            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
13015            'tags: ' + repr(self.tags) + ' ' +\
13016            'username: ' + repr(self.username) + ' ' +\
13017            '>'
13018
13019    def to_dict(self):
13020        return {
13021            'bind_interface': self.bind_interface,
13022            'egress_filter': self.egress_filter,
13023            'healthy': self.healthy,
13024            'hostname': self.hostname,
13025            'id': self.id,
13026            'name': self.name,
13027            'password': self.password,
13028            'port': self.port,
13029            'port_override': self.port_override,
13030            'secret_store_id': self.secret_store_id,
13031            'tags': self.tags,
13032            'username': self.username,
13033        }
13034
13035    @classmethod
13036    def from_dict(cls, d):
13037        return cls(
13038            bind_interface=d.get('bind_interface'),
13039            egress_filter=d.get('egress_filter'),
13040            healthy=d.get('healthy'),
13041            hostname=d.get('hostname'),
13042            id=d.get('id'),
13043            name=d.get('name'),
13044            password=d.get('password'),
13045            port=d.get('port'),
13046            port_override=d.get('port_override'),
13047            secret_store_id=d.get('secret_store_id'),
13048            tags=d.get('tags'),
13049            username=d.get('username'),
13050        )
13051
13052
13053class Tag:
13054    '''
13055
13056    '''
13057    __slots__ = [
13058        'name',
13059        'value',
13060    ]
13061
13062    def __init__(
13063        self,
13064        name=None,
13065        value=None,
13066    ):
13067        self.name = name if name is not None else ''
13068        '''
13069
13070        '''
13071        self.value = value if value is not None else ''
13072        '''
13073
13074        '''
13075
13076    def __repr__(self):
13077        return '<sdm.Tag ' + \
13078            'name: ' + repr(self.name) + ' ' +\
13079            'value: ' + repr(self.value) + ' ' +\
13080            '>'
13081
13082    def to_dict(self):
13083        return {
13084            'name': self.name,
13085            'value': self.value,
13086        }
13087
13088    @classmethod
13089    def from_dict(cls, d):
13090        return cls(
13091            name=d.get('name'),
13092            value=d.get('value'),
13093        )
13094
13095
13096class Teradata:
13097    '''
13098
13099    '''
13100    __slots__ = [
13101        'bind_interface',
13102        'egress_filter',
13103        'healthy',
13104        'hostname',
13105        'id',
13106        'name',
13107        'password',
13108        'port',
13109        'port_override',
13110        'secret_store_id',
13111        'tags',
13112        'username',
13113    ]
13114
13115    def __init__(
13116        self,
13117        bind_interface=None,
13118        egress_filter=None,
13119        healthy=None,
13120        hostname=None,
13121        id=None,
13122        name=None,
13123        password=None,
13124        port=None,
13125        port_override=None,
13126        secret_store_id=None,
13127        tags=None,
13128        username=None,
13129    ):
13130        self.bind_interface = bind_interface if bind_interface is not None else ''
13131        '''
13132         Bind interface
13133        '''
13134        self.egress_filter = egress_filter if egress_filter is not None else ''
13135        '''
13136         A filter applied to the routing logic to pin datasource to nodes.
13137        '''
13138        self.healthy = healthy if healthy is not None else False
13139        '''
13140         True if the datasource is reachable and the credentials are valid.
13141        '''
13142        self.hostname = hostname if hostname is not None else ''
13143        '''
13144
13145        '''
13146        self.id = id if id is not None else ''
13147        '''
13148         Unique identifier of the Resource.
13149        '''
13150        self.name = name if name is not None else ''
13151        '''
13152         Unique human-readable name of the Resource.
13153        '''
13154        self.password = password if password is not None else ''
13155        '''
13156
13157        '''
13158        self.port = port if port is not None else 0
13159        '''
13160
13161        '''
13162        self.port_override = port_override if port_override is not None else 0
13163        '''
13164
13165        '''
13166        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
13167        '''
13168         ID of the secret store containing credentials for this resource, if any.
13169        '''
13170        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
13171        '''
13172         Tags is a map of key, value pairs.
13173        '''
13174        self.username = username if username is not None else ''
13175        '''
13176
13177        '''
13178
13179    def __repr__(self):
13180        return '<sdm.Teradata ' + \
13181            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
13182            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
13183            'healthy: ' + repr(self.healthy) + ' ' +\
13184            'hostname: ' + repr(self.hostname) + ' ' +\
13185            'id: ' + repr(self.id) + ' ' +\
13186            'name: ' + repr(self.name) + ' ' +\
13187            'password: ' + repr(self.password) + ' ' +\
13188            'port: ' + repr(self.port) + ' ' +\
13189            'port_override: ' + repr(self.port_override) + ' ' +\
13190            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
13191            'tags: ' + repr(self.tags) + ' ' +\
13192            'username: ' + repr(self.username) + ' ' +\
13193            '>'
13194
13195    def to_dict(self):
13196        return {
13197            'bind_interface': self.bind_interface,
13198            'egress_filter': self.egress_filter,
13199            'healthy': self.healthy,
13200            'hostname': self.hostname,
13201            'id': self.id,
13202            'name': self.name,
13203            'password': self.password,
13204            'port': self.port,
13205            'port_override': self.port_override,
13206            'secret_store_id': self.secret_store_id,
13207            'tags': self.tags,
13208            'username': self.username,
13209        }
13210
13211    @classmethod
13212    def from_dict(cls, d):
13213        return cls(
13214            bind_interface=d.get('bind_interface'),
13215            egress_filter=d.get('egress_filter'),
13216            healthy=d.get('healthy'),
13217            hostname=d.get('hostname'),
13218            id=d.get('id'),
13219            name=d.get('name'),
13220            password=d.get('password'),
13221            port=d.get('port'),
13222            port_override=d.get('port_override'),
13223            secret_store_id=d.get('secret_store_id'),
13224            tags=d.get('tags'),
13225            username=d.get('username'),
13226        )
13227
13228
13229class UpdateResponseMetadata:
13230    '''
13231     UpdateResponseMetadata is reserved for future use.
13232    '''
13233    __slots__ = []
13234
13235    def __init__(self, ):
13236        pass
13237
13238    def __repr__(self):
13239        return '<sdm.UpdateResponseMetadata ' + \
13240            '>'
13241
13242    def to_dict(self):
13243        return {}
13244
13245    @classmethod
13246    def from_dict(cls, d):
13247        return cls()
13248
13249
13250class User:
13251    '''
13252     A User can connect to resources they are granted directly, or granted
13253     via roles.
13254    '''
13255    __slots__ = [
13256        'email',
13257        'first_name',
13258        'id',
13259        'last_name',
13260        'suspended',
13261        'tags',
13262    ]
13263
13264    def __init__(
13265        self,
13266        email=None,
13267        first_name=None,
13268        id=None,
13269        last_name=None,
13270        suspended=None,
13271        tags=None,
13272    ):
13273        self.email = email if email is not None else ''
13274        '''
13275         The User's email address. Must be unique.
13276        '''
13277        self.first_name = first_name if first_name is not None else ''
13278        '''
13279         The User's first name.
13280        '''
13281        self.id = id if id is not None else ''
13282        '''
13283         Unique identifier of the User.
13284        '''
13285        self.last_name = last_name if last_name is not None else ''
13286        '''
13287         The User's last name.
13288        '''
13289        self.suspended = suspended if suspended is not None else False
13290        '''
13291         The User's suspended state.
13292        '''
13293        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
13294        '''
13295         Tags is a map of key, value pairs.
13296        '''
13297
13298    def __repr__(self):
13299        return '<sdm.User ' + \
13300            'email: ' + repr(self.email) + ' ' +\
13301            'first_name: ' + repr(self.first_name) + ' ' +\
13302            'id: ' + repr(self.id) + ' ' +\
13303            'last_name: ' + repr(self.last_name) + ' ' +\
13304            'suspended: ' + repr(self.suspended) + ' ' +\
13305            'tags: ' + repr(self.tags) + ' ' +\
13306            '>'
13307
13308    def to_dict(self):
13309        return {
13310            'email': self.email,
13311            'first_name': self.first_name,
13312            'id': self.id,
13313            'last_name': self.last_name,
13314            'suspended': self.suspended,
13315            'tags': self.tags,
13316        }
13317
13318    @classmethod
13319    def from_dict(cls, d):
13320        return cls(
13321            email=d.get('email'),
13322            first_name=d.get('first_name'),
13323            id=d.get('id'),
13324            last_name=d.get('last_name'),
13325            suspended=d.get('suspended'),
13326            tags=d.get('tags'),
13327        )
13328
13329
13330class VaultAppRoleStore:
13331    '''
13332
13333    '''
13334    __slots__ = [
13335        'id',
13336        'name',
13337        'namespace',
13338        'server_address',
13339        'tags',
13340    ]
13341
13342    def __init__(
13343        self,
13344        id=None,
13345        name=None,
13346        namespace=None,
13347        server_address=None,
13348        tags=None,
13349    ):
13350        self.id = id if id is not None else ''
13351        '''
13352         Unique identifier of the SecretStore.
13353        '''
13354        self.name = name if name is not None else ''
13355        '''
13356         Unique human-readable name of the SecretStore.
13357        '''
13358        self.namespace = namespace if namespace is not None else ''
13359        '''
13360
13361        '''
13362        self.server_address = server_address if server_address is not None else ''
13363        '''
13364
13365        '''
13366        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
13367        '''
13368         Tags is a map of key, value pairs.
13369        '''
13370
13371    def __repr__(self):
13372        return '<sdm.VaultAppRoleStore ' + \
13373            'id: ' + repr(self.id) + ' ' +\
13374            'name: ' + repr(self.name) + ' ' +\
13375            'namespace: ' + repr(self.namespace) + ' ' +\
13376            'server_address: ' + repr(self.server_address) + ' ' +\
13377            'tags: ' + repr(self.tags) + ' ' +\
13378            '>'
13379
13380    def to_dict(self):
13381        return {
13382            'id': self.id,
13383            'name': self.name,
13384            'namespace': self.namespace,
13385            'server_address': self.server_address,
13386            'tags': self.tags,
13387        }
13388
13389    @classmethod
13390    def from_dict(cls, d):
13391        return cls(
13392            id=d.get('id'),
13393            name=d.get('name'),
13394            namespace=d.get('namespace'),
13395            server_address=d.get('server_address'),
13396            tags=d.get('tags'),
13397        )
13398
13399
13400class VaultTLSStore:
13401    '''
13402
13403    '''
13404    __slots__ = [
13405        'ca_cert_path',
13406        'client_cert_path',
13407        'client_key_path',
13408        'id',
13409        'name',
13410        'namespace',
13411        'server_address',
13412        'tags',
13413    ]
13414
13415    def __init__(
13416        self,
13417        ca_cert_path=None,
13418        client_cert_path=None,
13419        client_key_path=None,
13420        id=None,
13421        name=None,
13422        namespace=None,
13423        server_address=None,
13424        tags=None,
13425    ):
13426        self.ca_cert_path = ca_cert_path if ca_cert_path is not None else ''
13427        '''
13428
13429        '''
13430        self.client_cert_path = client_cert_path if client_cert_path is not None else ''
13431        '''
13432
13433        '''
13434        self.client_key_path = client_key_path if client_key_path is not None else ''
13435        '''
13436
13437        '''
13438        self.id = id if id is not None else ''
13439        '''
13440         Unique identifier of the SecretStore.
13441        '''
13442        self.name = name if name is not None else ''
13443        '''
13444         Unique human-readable name of the SecretStore.
13445        '''
13446        self.namespace = namespace if namespace is not None else ''
13447        '''
13448
13449        '''
13450        self.server_address = server_address if server_address is not None else ''
13451        '''
13452
13453        '''
13454        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
13455        '''
13456         Tags is a map of key, value pairs.
13457        '''
13458
13459    def __repr__(self):
13460        return '<sdm.VaultTLSStore ' + \
13461            'ca_cert_path: ' + repr(self.ca_cert_path) + ' ' +\
13462            'client_cert_path: ' + repr(self.client_cert_path) + ' ' +\
13463            'client_key_path: ' + repr(self.client_key_path) + ' ' +\
13464            'id: ' + repr(self.id) + ' ' +\
13465            'name: ' + repr(self.name) + ' ' +\
13466            'namespace: ' + repr(self.namespace) + ' ' +\
13467            'server_address: ' + repr(self.server_address) + ' ' +\
13468            'tags: ' + repr(self.tags) + ' ' +\
13469            '>'
13470
13471    def to_dict(self):
13472        return {
13473            'ca_cert_path': self.ca_cert_path,
13474            'client_cert_path': self.client_cert_path,
13475            'client_key_path': self.client_key_path,
13476            'id': self.id,
13477            'name': self.name,
13478            'namespace': self.namespace,
13479            'server_address': self.server_address,
13480            'tags': self.tags,
13481        }
13482
13483    @classmethod
13484    def from_dict(cls, d):
13485        return cls(
13486            ca_cert_path=d.get('ca_cert_path'),
13487            client_cert_path=d.get('client_cert_path'),
13488            client_key_path=d.get('client_key_path'),
13489            id=d.get('id'),
13490            name=d.get('name'),
13491            namespace=d.get('namespace'),
13492            server_address=d.get('server_address'),
13493            tags=d.get('tags'),
13494        )
13495
13496
13497class VaultTokenStore:
13498    '''
13499
13500    '''
13501    __slots__ = [
13502        'id',
13503        'name',
13504        'namespace',
13505        'server_address',
13506        'tags',
13507    ]
13508
13509    def __init__(
13510        self,
13511        id=None,
13512        name=None,
13513        namespace=None,
13514        server_address=None,
13515        tags=None,
13516    ):
13517        self.id = id if id is not None else ''
13518        '''
13519         Unique identifier of the SecretStore.
13520        '''
13521        self.name = name if name is not None else ''
13522        '''
13523         Unique human-readable name of the SecretStore.
13524        '''
13525        self.namespace = namespace if namespace is not None else ''
13526        '''
13527
13528        '''
13529        self.server_address = server_address if server_address is not None else ''
13530        '''
13531
13532        '''
13533        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
13534        '''
13535         Tags is a map of key, value pairs.
13536        '''
13537
13538    def __repr__(self):
13539        return '<sdm.VaultTokenStore ' + \
13540            'id: ' + repr(self.id) + ' ' +\
13541            'name: ' + repr(self.name) + ' ' +\
13542            'namespace: ' + repr(self.namespace) + ' ' +\
13543            'server_address: ' + repr(self.server_address) + ' ' +\
13544            'tags: ' + repr(self.tags) + ' ' +\
13545            '>'
13546
13547    def to_dict(self):
13548        return {
13549            'id': self.id,
13550            'name': self.name,
13551            'namespace': self.namespace,
13552            'server_address': self.server_address,
13553            'tags': self.tags,
13554        }
13555
13556    @classmethod
13557    def from_dict(cls, d):
13558        return cls(
13559            id=d.get('id'),
13560            name=d.get('name'),
13561            namespace=d.get('namespace'),
13562            server_address=d.get('server_address'),
13563            tags=d.get('tags'),
13564        )
13565
13566
13567def _porcelain_zero_value_tags():
13568    return {}
13569
13570
13571def _porcelain_zero_value_access_rules():
13572    return []
class AKS:
 22class AKS:
 23    '''
 24
 25    '''
 26    __slots__ = [
 27        'bind_interface',
 28        'certificate_authority',
 29        'client_certificate',
 30        'client_key',
 31        'egress_filter',
 32        'healthcheck_namespace',
 33        'healthy',
 34        'hostname',
 35        'id',
 36        'name',
 37        'port',
 38        'remote_identity_group_id',
 39        'remote_identity_healthcheck_username',
 40        'secret_store_id',
 41        'tags',
 42    ]
 43
 44    def __init__(
 45        self,
 46        bind_interface=None,
 47        certificate_authority=None,
 48        client_certificate=None,
 49        client_key=None,
 50        egress_filter=None,
 51        healthcheck_namespace=None,
 52        healthy=None,
 53        hostname=None,
 54        id=None,
 55        name=None,
 56        port=None,
 57        remote_identity_group_id=None,
 58        remote_identity_healthcheck_username=None,
 59        secret_store_id=None,
 60        tags=None,
 61    ):
 62        self.bind_interface = bind_interface if bind_interface is not None else ''
 63        '''
 64         Bind interface
 65        '''
 66        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 67        '''
 68
 69        '''
 70        self.client_certificate = client_certificate if client_certificate is not None else ''
 71        '''
 72
 73        '''
 74        self.client_key = client_key if client_key is not None else ''
 75        '''
 76
 77        '''
 78        self.egress_filter = egress_filter if egress_filter is not None else ''
 79        '''
 80         A filter applied to the routing logic to pin datasource to nodes.
 81        '''
 82        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 83        '''
 84         The path used to check the health of your connection.  Defaults to `default`.
 85        '''
 86        self.healthy = healthy if healthy is not None else False
 87        '''
 88         True if the datasource is reachable and the credentials are valid.
 89        '''
 90        self.hostname = hostname if hostname is not None else ''
 91        '''
 92
 93        '''
 94        self.id = id if id is not None else ''
 95        '''
 96         Unique identifier of the Resource.
 97        '''
 98        self.name = name if name is not None else ''
 99        '''
100         Unique human-readable name of the Resource.
101        '''
102        self.port = port if port is not None else 0
103        '''
104
105        '''
106        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
107        '''
108
109        '''
110        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
111        '''
112
113        '''
114        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
115        '''
116         ID of the secret store containing credentials for this resource, if any.
117        '''
118        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
119        '''
120         Tags is a map of key, value pairs.
121        '''
122
123    def __repr__(self):
124        return '<sdm.AKS ' + \
125            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
126            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
127            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
128            'client_key: ' + repr(self.client_key) + ' ' +\
129            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
130            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
131            'healthy: ' + repr(self.healthy) + ' ' +\
132            'hostname: ' + repr(self.hostname) + ' ' +\
133            'id: ' + repr(self.id) + ' ' +\
134            'name: ' + repr(self.name) + ' ' +\
135            'port: ' + repr(self.port) + ' ' +\
136            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
137            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
138            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
139            'tags: ' + repr(self.tags) + ' ' +\
140            '>'
141
142    def to_dict(self):
143        return {
144            'bind_interface': self.bind_interface,
145            'certificate_authority': self.certificate_authority,
146            'client_certificate': self.client_certificate,
147            'client_key': self.client_key,
148            'egress_filter': self.egress_filter,
149            'healthcheck_namespace': self.healthcheck_namespace,
150            'healthy': self.healthy,
151            'hostname': self.hostname,
152            'id': self.id,
153            'name': self.name,
154            'port': self.port,
155            'remote_identity_group_id': self.remote_identity_group_id,
156            'remote_identity_healthcheck_username':
157            self.remote_identity_healthcheck_username,
158            'secret_store_id': self.secret_store_id,
159            'tags': self.tags,
160        }
161
162    @classmethod
163    def from_dict(cls, d):
164        return cls(
165            bind_interface=d.get('bind_interface'),
166            certificate_authority=d.get('certificate_authority'),
167            client_certificate=d.get('client_certificate'),
168            client_key=d.get('client_key'),
169            egress_filter=d.get('egress_filter'),
170            healthcheck_namespace=d.get('healthcheck_namespace'),
171            healthy=d.get('healthy'),
172            hostname=d.get('hostname'),
173            id=d.get('id'),
174            name=d.get('name'),
175            port=d.get('port'),
176            remote_identity_group_id=d.get('remote_identity_group_id'),
177            remote_identity_healthcheck_username=d.get(
178                'remote_identity_healthcheck_username'),
179            secret_store_id=d.get('secret_store_id'),
180            tags=d.get('tags'),
181        )
AKS( bind_interface=None, certificate_authority=None, client_certificate=None, client_key=None, egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, port=None, remote_identity_group_id=None, remote_identity_healthcheck_username=None, secret_store_id=None, tags=None)
 44    def __init__(
 45        self,
 46        bind_interface=None,
 47        certificate_authority=None,
 48        client_certificate=None,
 49        client_key=None,
 50        egress_filter=None,
 51        healthcheck_namespace=None,
 52        healthy=None,
 53        hostname=None,
 54        id=None,
 55        name=None,
 56        port=None,
 57        remote_identity_group_id=None,
 58        remote_identity_healthcheck_username=None,
 59        secret_store_id=None,
 60        tags=None,
 61    ):
 62        self.bind_interface = bind_interface if bind_interface is not None else ''
 63        '''
 64         Bind interface
 65        '''
 66        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
 67        '''
 68
 69        '''
 70        self.client_certificate = client_certificate if client_certificate is not None else ''
 71        '''
 72
 73        '''
 74        self.client_key = client_key if client_key is not None else ''
 75        '''
 76
 77        '''
 78        self.egress_filter = egress_filter if egress_filter is not None else ''
 79        '''
 80         A filter applied to the routing logic to pin datasource to nodes.
 81        '''
 82        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
 83        '''
 84         The path used to check the health of your connection.  Defaults to `default`.
 85        '''
 86        self.healthy = healthy if healthy is not None else False
 87        '''
 88         True if the datasource is reachable and the credentials are valid.
 89        '''
 90        self.hostname = hostname if hostname is not None else ''
 91        '''
 92
 93        '''
 94        self.id = id if id is not None else ''
 95        '''
 96         Unique identifier of the Resource.
 97        '''
 98        self.name = name if name is not None else ''
 99        '''
100         Unique human-readable name of the Resource.
101        '''
102        self.port = port if port is not None else 0
103        '''
104
105        '''
106        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
107        '''
108
109        '''
110        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
111        '''
112
113        '''
114        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
115        '''
116         ID of the secret store containing credentials for this resource, if any.
117        '''
118        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
119        '''
120         Tags is a map of key, value pairs.
121        '''
bind_interface

Bind interface

certificate_authority
client_certificate
client_key
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
remote_identity_group_id
remote_identity_healthcheck_username
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
142    def to_dict(self):
143        return {
144            'bind_interface': self.bind_interface,
145            'certificate_authority': self.certificate_authority,
146            'client_certificate': self.client_certificate,
147            'client_key': self.client_key,
148            'egress_filter': self.egress_filter,
149            'healthcheck_namespace': self.healthcheck_namespace,
150            'healthy': self.healthy,
151            'hostname': self.hostname,
152            'id': self.id,
153            'name': self.name,
154            'port': self.port,
155            'remote_identity_group_id': self.remote_identity_group_id,
156            'remote_identity_healthcheck_username':
157            self.remote_identity_healthcheck_username,
158            'secret_store_id': self.secret_store_id,
159            'tags': self.tags,
160        }
@classmethod
def from_dict(cls, d)
162    @classmethod
163    def from_dict(cls, d):
164        return cls(
165            bind_interface=d.get('bind_interface'),
166            certificate_authority=d.get('certificate_authority'),
167            client_certificate=d.get('client_certificate'),
168            client_key=d.get('client_key'),
169            egress_filter=d.get('egress_filter'),
170            healthcheck_namespace=d.get('healthcheck_namespace'),
171            healthy=d.get('healthy'),
172            hostname=d.get('hostname'),
173            id=d.get('id'),
174            name=d.get('name'),
175            port=d.get('port'),
176            remote_identity_group_id=d.get('remote_identity_group_id'),
177            remote_identity_healthcheck_username=d.get(
178                'remote_identity_healthcheck_username'),
179            secret_store_id=d.get('secret_store_id'),
180            tags=d.get('tags'),
181        )
class AKSBasicAuth:
184class AKSBasicAuth:
185    '''
186
187    '''
188    __slots__ = [
189        'bind_interface',
190        'egress_filter',
191        'healthcheck_namespace',
192        'healthy',
193        'hostname',
194        'id',
195        'name',
196        'password',
197        'port',
198        'secret_store_id',
199        'tags',
200        'username',
201    ]
202
203    def __init__(
204        self,
205        bind_interface=None,
206        egress_filter=None,
207        healthcheck_namespace=None,
208        healthy=None,
209        hostname=None,
210        id=None,
211        name=None,
212        password=None,
213        port=None,
214        secret_store_id=None,
215        tags=None,
216        username=None,
217    ):
218        self.bind_interface = bind_interface if bind_interface is not None else ''
219        '''
220         Bind interface
221        '''
222        self.egress_filter = egress_filter if egress_filter is not None else ''
223        '''
224         A filter applied to the routing logic to pin datasource to nodes.
225        '''
226        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
227        '''
228         The path used to check the health of your connection.  Defaults to `default`.
229        '''
230        self.healthy = healthy if healthy is not None else False
231        '''
232         True if the datasource is reachable and the credentials are valid.
233        '''
234        self.hostname = hostname if hostname is not None else ''
235        '''
236
237        '''
238        self.id = id if id is not None else ''
239        '''
240         Unique identifier of the Resource.
241        '''
242        self.name = name if name is not None else ''
243        '''
244         Unique human-readable name of the Resource.
245        '''
246        self.password = password if password is not None else ''
247        '''
248
249        '''
250        self.port = port if port is not None else 0
251        '''
252
253        '''
254        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
255        '''
256         ID of the secret store containing credentials for this resource, if any.
257        '''
258        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
259        '''
260         Tags is a map of key, value pairs.
261        '''
262        self.username = username if username is not None else ''
263        '''
264
265        '''
266
267    def __repr__(self):
268        return '<sdm.AKSBasicAuth ' + \
269            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
270            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
271            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
272            'healthy: ' + repr(self.healthy) + ' ' +\
273            'hostname: ' + repr(self.hostname) + ' ' +\
274            'id: ' + repr(self.id) + ' ' +\
275            'name: ' + repr(self.name) + ' ' +\
276            'password: ' + repr(self.password) + ' ' +\
277            'port: ' + repr(self.port) + ' ' +\
278            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
279            'tags: ' + repr(self.tags) + ' ' +\
280            'username: ' + repr(self.username) + ' ' +\
281            '>'
282
283    def to_dict(self):
284        return {
285            'bind_interface': self.bind_interface,
286            'egress_filter': self.egress_filter,
287            'healthcheck_namespace': self.healthcheck_namespace,
288            'healthy': self.healthy,
289            'hostname': self.hostname,
290            'id': self.id,
291            'name': self.name,
292            'password': self.password,
293            'port': self.port,
294            'secret_store_id': self.secret_store_id,
295            'tags': self.tags,
296            'username': self.username,
297        }
298
299    @classmethod
300    def from_dict(cls, d):
301        return cls(
302            bind_interface=d.get('bind_interface'),
303            egress_filter=d.get('egress_filter'),
304            healthcheck_namespace=d.get('healthcheck_namespace'),
305            healthy=d.get('healthy'),
306            hostname=d.get('hostname'),
307            id=d.get('id'),
308            name=d.get('name'),
309            password=d.get('password'),
310            port=d.get('port'),
311            secret_store_id=d.get('secret_store_id'),
312            tags=d.get('tags'),
313            username=d.get('username'),
314        )
AKSBasicAuth( bind_interface=None, egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, secret_store_id=None, tags=None, username=None)
203    def __init__(
204        self,
205        bind_interface=None,
206        egress_filter=None,
207        healthcheck_namespace=None,
208        healthy=None,
209        hostname=None,
210        id=None,
211        name=None,
212        password=None,
213        port=None,
214        secret_store_id=None,
215        tags=None,
216        username=None,
217    ):
218        self.bind_interface = bind_interface if bind_interface is not None else ''
219        '''
220         Bind interface
221        '''
222        self.egress_filter = egress_filter if egress_filter is not None else ''
223        '''
224         A filter applied to the routing logic to pin datasource to nodes.
225        '''
226        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
227        '''
228         The path used to check the health of your connection.  Defaults to `default`.
229        '''
230        self.healthy = healthy if healthy is not None else False
231        '''
232         True if the datasource is reachable and the credentials are valid.
233        '''
234        self.hostname = hostname if hostname is not None else ''
235        '''
236
237        '''
238        self.id = id if id is not None else ''
239        '''
240         Unique identifier of the Resource.
241        '''
242        self.name = name if name is not None else ''
243        '''
244         Unique human-readable name of the Resource.
245        '''
246        self.password = password if password is not None else ''
247        '''
248
249        '''
250        self.port = port if port is not None else 0
251        '''
252
253        '''
254        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
255        '''
256         ID of the secret store containing credentials for this resource, if any.
257        '''
258        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
259        '''
260         Tags is a map of key, value pairs.
261        '''
262        self.username = username if username is not None else ''
263        '''
264
265        '''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
283    def to_dict(self):
284        return {
285            'bind_interface': self.bind_interface,
286            'egress_filter': self.egress_filter,
287            'healthcheck_namespace': self.healthcheck_namespace,
288            'healthy': self.healthy,
289            'hostname': self.hostname,
290            'id': self.id,
291            'name': self.name,
292            'password': self.password,
293            'port': self.port,
294            'secret_store_id': self.secret_store_id,
295            'tags': self.tags,
296            'username': self.username,
297        }
@classmethod
def from_dict(cls, d)
299    @classmethod
300    def from_dict(cls, d):
301        return cls(
302            bind_interface=d.get('bind_interface'),
303            egress_filter=d.get('egress_filter'),
304            healthcheck_namespace=d.get('healthcheck_namespace'),
305            healthy=d.get('healthy'),
306            hostname=d.get('hostname'),
307            id=d.get('id'),
308            name=d.get('name'),
309            password=d.get('password'),
310            port=d.get('port'),
311            secret_store_id=d.get('secret_store_id'),
312            tags=d.get('tags'),
313            username=d.get('username'),
314        )
class AKSServiceAccount:
317class AKSServiceAccount:
318    '''
319
320    '''
321    __slots__ = [
322        'bind_interface',
323        'egress_filter',
324        'healthcheck_namespace',
325        'healthy',
326        'hostname',
327        'id',
328        'name',
329        'port',
330        'remote_identity_group_id',
331        'remote_identity_healthcheck_username',
332        'secret_store_id',
333        'tags',
334        'token',
335    ]
336
337    def __init__(
338        self,
339        bind_interface=None,
340        egress_filter=None,
341        healthcheck_namespace=None,
342        healthy=None,
343        hostname=None,
344        id=None,
345        name=None,
346        port=None,
347        remote_identity_group_id=None,
348        remote_identity_healthcheck_username=None,
349        secret_store_id=None,
350        tags=None,
351        token=None,
352    ):
353        self.bind_interface = bind_interface if bind_interface is not None else ''
354        '''
355         Bind interface
356        '''
357        self.egress_filter = egress_filter if egress_filter is not None else ''
358        '''
359         A filter applied to the routing logic to pin datasource to nodes.
360        '''
361        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
362        '''
363         The path used to check the health of your connection.  Defaults to `default`.
364        '''
365        self.healthy = healthy if healthy is not None else False
366        '''
367         True if the datasource is reachable and the credentials are valid.
368        '''
369        self.hostname = hostname if hostname is not None else ''
370        '''
371
372        '''
373        self.id = id if id is not None else ''
374        '''
375         Unique identifier of the Resource.
376        '''
377        self.name = name if name is not None else ''
378        '''
379         Unique human-readable name of the Resource.
380        '''
381        self.port = port if port is not None else 0
382        '''
383
384        '''
385        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
386        '''
387
388        '''
389        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
390        '''
391
392        '''
393        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
394        '''
395         ID of the secret store containing credentials for this resource, if any.
396        '''
397        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
398        '''
399         Tags is a map of key, value pairs.
400        '''
401        self.token = token if token is not None else ''
402        '''
403
404        '''
405
406    def __repr__(self):
407        return '<sdm.AKSServiceAccount ' + \
408            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
409            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
410            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
411            'healthy: ' + repr(self.healthy) + ' ' +\
412            'hostname: ' + repr(self.hostname) + ' ' +\
413            'id: ' + repr(self.id) + ' ' +\
414            'name: ' + repr(self.name) + ' ' +\
415            'port: ' + repr(self.port) + ' ' +\
416            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
417            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
418            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
419            'tags: ' + repr(self.tags) + ' ' +\
420            'token: ' + repr(self.token) + ' ' +\
421            '>'
422
423    def to_dict(self):
424        return {
425            'bind_interface': self.bind_interface,
426            'egress_filter': self.egress_filter,
427            'healthcheck_namespace': self.healthcheck_namespace,
428            'healthy': self.healthy,
429            'hostname': self.hostname,
430            'id': self.id,
431            'name': self.name,
432            'port': self.port,
433            'remote_identity_group_id': self.remote_identity_group_id,
434            'remote_identity_healthcheck_username':
435            self.remote_identity_healthcheck_username,
436            'secret_store_id': self.secret_store_id,
437            'tags': self.tags,
438            'token': self.token,
439        }
440
441    @classmethod
442    def from_dict(cls, d):
443        return cls(
444            bind_interface=d.get('bind_interface'),
445            egress_filter=d.get('egress_filter'),
446            healthcheck_namespace=d.get('healthcheck_namespace'),
447            healthy=d.get('healthy'),
448            hostname=d.get('hostname'),
449            id=d.get('id'),
450            name=d.get('name'),
451            port=d.get('port'),
452            remote_identity_group_id=d.get('remote_identity_group_id'),
453            remote_identity_healthcheck_username=d.get(
454                'remote_identity_healthcheck_username'),
455            secret_store_id=d.get('secret_store_id'),
456            tags=d.get('tags'),
457            token=d.get('token'),
458        )
AKSServiceAccount( bind_interface=None, egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, port=None, remote_identity_group_id=None, remote_identity_healthcheck_username=None, secret_store_id=None, tags=None, token=None)
337    def __init__(
338        self,
339        bind_interface=None,
340        egress_filter=None,
341        healthcheck_namespace=None,
342        healthy=None,
343        hostname=None,
344        id=None,
345        name=None,
346        port=None,
347        remote_identity_group_id=None,
348        remote_identity_healthcheck_username=None,
349        secret_store_id=None,
350        tags=None,
351        token=None,
352    ):
353        self.bind_interface = bind_interface if bind_interface is not None else ''
354        '''
355         Bind interface
356        '''
357        self.egress_filter = egress_filter if egress_filter is not None else ''
358        '''
359         A filter applied to the routing logic to pin datasource to nodes.
360        '''
361        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
362        '''
363         The path used to check the health of your connection.  Defaults to `default`.
364        '''
365        self.healthy = healthy if healthy is not None else False
366        '''
367         True if the datasource is reachable and the credentials are valid.
368        '''
369        self.hostname = hostname if hostname is not None else ''
370        '''
371
372        '''
373        self.id = id if id is not None else ''
374        '''
375         Unique identifier of the Resource.
376        '''
377        self.name = name if name is not None else ''
378        '''
379         Unique human-readable name of the Resource.
380        '''
381        self.port = port if port is not None else 0
382        '''
383
384        '''
385        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
386        '''
387
388        '''
389        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
390        '''
391
392        '''
393        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
394        '''
395         ID of the secret store containing credentials for this resource, if any.
396        '''
397        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
398        '''
399         Tags is a map of key, value pairs.
400        '''
401        self.token = token if token is not None else ''
402        '''
403
404        '''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
remote_identity_group_id
remote_identity_healthcheck_username
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

token
def to_dict(self)
423    def to_dict(self):
424        return {
425            'bind_interface': self.bind_interface,
426            'egress_filter': self.egress_filter,
427            'healthcheck_namespace': self.healthcheck_namespace,
428            'healthy': self.healthy,
429            'hostname': self.hostname,
430            'id': self.id,
431            'name': self.name,
432            'port': self.port,
433            'remote_identity_group_id': self.remote_identity_group_id,
434            'remote_identity_healthcheck_username':
435            self.remote_identity_healthcheck_username,
436            'secret_store_id': self.secret_store_id,
437            'tags': self.tags,
438            'token': self.token,
439        }
@classmethod
def from_dict(cls, d)
441    @classmethod
442    def from_dict(cls, d):
443        return cls(
444            bind_interface=d.get('bind_interface'),
445            egress_filter=d.get('egress_filter'),
446            healthcheck_namespace=d.get('healthcheck_namespace'),
447            healthy=d.get('healthy'),
448            hostname=d.get('hostname'),
449            id=d.get('id'),
450            name=d.get('name'),
451            port=d.get('port'),
452            remote_identity_group_id=d.get('remote_identity_group_id'),
453            remote_identity_healthcheck_username=d.get(
454                'remote_identity_healthcheck_username'),
455            secret_store_id=d.get('secret_store_id'),
456            tags=d.get('tags'),
457            token=d.get('token'),
458        )
class AKSServiceAccountUserImpersonation:
461class AKSServiceAccountUserImpersonation:
462    '''
463
464    '''
465    __slots__ = [
466        'bind_interface',
467        'egress_filter',
468        'healthcheck_namespace',
469        'healthy',
470        'hostname',
471        'id',
472        'name',
473        'port',
474        'secret_store_id',
475        'tags',
476        'token',
477    ]
478
479    def __init__(
480        self,
481        bind_interface=None,
482        egress_filter=None,
483        healthcheck_namespace=None,
484        healthy=None,
485        hostname=None,
486        id=None,
487        name=None,
488        port=None,
489        secret_store_id=None,
490        tags=None,
491        token=None,
492    ):
493        self.bind_interface = bind_interface if bind_interface is not None else ''
494        '''
495         Bind interface
496        '''
497        self.egress_filter = egress_filter if egress_filter is not None else ''
498        '''
499         A filter applied to the routing logic to pin datasource to nodes.
500        '''
501        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
502        '''
503         The path used to check the health of your connection.  Defaults to `default`.
504        '''
505        self.healthy = healthy if healthy is not None else False
506        '''
507         True if the datasource is reachable and the credentials are valid.
508        '''
509        self.hostname = hostname if hostname is not None else ''
510        '''
511
512        '''
513        self.id = id if id is not None else ''
514        '''
515         Unique identifier of the Resource.
516        '''
517        self.name = name if name is not None else ''
518        '''
519         Unique human-readable name of the Resource.
520        '''
521        self.port = port if port is not None else 0
522        '''
523
524        '''
525        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
526        '''
527         ID of the secret store containing credentials for this resource, if any.
528        '''
529        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
530        '''
531         Tags is a map of key, value pairs.
532        '''
533        self.token = token if token is not None else ''
534        '''
535
536        '''
537
538    def __repr__(self):
539        return '<sdm.AKSServiceAccountUserImpersonation ' + \
540            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
541            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
542            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
543            'healthy: ' + repr(self.healthy) + ' ' +\
544            'hostname: ' + repr(self.hostname) + ' ' +\
545            'id: ' + repr(self.id) + ' ' +\
546            'name: ' + repr(self.name) + ' ' +\
547            'port: ' + repr(self.port) + ' ' +\
548            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
549            'tags: ' + repr(self.tags) + ' ' +\
550            'token: ' + repr(self.token) + ' ' +\
551            '>'
552
553    def to_dict(self):
554        return {
555            'bind_interface': self.bind_interface,
556            'egress_filter': self.egress_filter,
557            'healthcheck_namespace': self.healthcheck_namespace,
558            'healthy': self.healthy,
559            'hostname': self.hostname,
560            'id': self.id,
561            'name': self.name,
562            'port': self.port,
563            'secret_store_id': self.secret_store_id,
564            'tags': self.tags,
565            'token': self.token,
566        }
567
568    @classmethod
569    def from_dict(cls, d):
570        return cls(
571            bind_interface=d.get('bind_interface'),
572            egress_filter=d.get('egress_filter'),
573            healthcheck_namespace=d.get('healthcheck_namespace'),
574            healthy=d.get('healthy'),
575            hostname=d.get('hostname'),
576            id=d.get('id'),
577            name=d.get('name'),
578            port=d.get('port'),
579            secret_store_id=d.get('secret_store_id'),
580            tags=d.get('tags'),
581            token=d.get('token'),
582        )
AKSServiceAccountUserImpersonation( bind_interface=None, egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, port=None, secret_store_id=None, tags=None, token=None)
479    def __init__(
480        self,
481        bind_interface=None,
482        egress_filter=None,
483        healthcheck_namespace=None,
484        healthy=None,
485        hostname=None,
486        id=None,
487        name=None,
488        port=None,
489        secret_store_id=None,
490        tags=None,
491        token=None,
492    ):
493        self.bind_interface = bind_interface if bind_interface is not None else ''
494        '''
495         Bind interface
496        '''
497        self.egress_filter = egress_filter if egress_filter is not None else ''
498        '''
499         A filter applied to the routing logic to pin datasource to nodes.
500        '''
501        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
502        '''
503         The path used to check the health of your connection.  Defaults to `default`.
504        '''
505        self.healthy = healthy if healthy is not None else False
506        '''
507         True if the datasource is reachable and the credentials are valid.
508        '''
509        self.hostname = hostname if hostname is not None else ''
510        '''
511
512        '''
513        self.id = id if id is not None else ''
514        '''
515         Unique identifier of the Resource.
516        '''
517        self.name = name if name is not None else ''
518        '''
519         Unique human-readable name of the Resource.
520        '''
521        self.port = port if port is not None else 0
522        '''
523
524        '''
525        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
526        '''
527         ID of the secret store containing credentials for this resource, if any.
528        '''
529        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
530        '''
531         Tags is a map of key, value pairs.
532        '''
533        self.token = token if token is not None else ''
534        '''
535
536        '''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

token
def to_dict(self)
553    def to_dict(self):
554        return {
555            'bind_interface': self.bind_interface,
556            'egress_filter': self.egress_filter,
557            'healthcheck_namespace': self.healthcheck_namespace,
558            'healthy': self.healthy,
559            'hostname': self.hostname,
560            'id': self.id,
561            'name': self.name,
562            'port': self.port,
563            'secret_store_id': self.secret_store_id,
564            'tags': self.tags,
565            'token': self.token,
566        }
@classmethod
def from_dict(cls, d)
568    @classmethod
569    def from_dict(cls, d):
570        return cls(
571            bind_interface=d.get('bind_interface'),
572            egress_filter=d.get('egress_filter'),
573            healthcheck_namespace=d.get('healthcheck_namespace'),
574            healthy=d.get('healthy'),
575            hostname=d.get('hostname'),
576            id=d.get('id'),
577            name=d.get('name'),
578            port=d.get('port'),
579            secret_store_id=d.get('secret_store_id'),
580            tags=d.get('tags'),
581            token=d.get('token'),
582        )
class AKSUserImpersonation:
585class AKSUserImpersonation:
586    '''
587
588    '''
589    __slots__ = [
590        'bind_interface',
591        'certificate_authority',
592        'client_certificate',
593        'client_key',
594        'egress_filter',
595        'healthcheck_namespace',
596        'healthy',
597        'hostname',
598        'id',
599        'name',
600        'port',
601        'secret_store_id',
602        'tags',
603    ]
604
605    def __init__(
606        self,
607        bind_interface=None,
608        certificate_authority=None,
609        client_certificate=None,
610        client_key=None,
611        egress_filter=None,
612        healthcheck_namespace=None,
613        healthy=None,
614        hostname=None,
615        id=None,
616        name=None,
617        port=None,
618        secret_store_id=None,
619        tags=None,
620    ):
621        self.bind_interface = bind_interface if bind_interface is not None else ''
622        '''
623         Bind interface
624        '''
625        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
626        '''
627
628        '''
629        self.client_certificate = client_certificate if client_certificate is not None else ''
630        '''
631
632        '''
633        self.client_key = client_key if client_key is not None else ''
634        '''
635
636        '''
637        self.egress_filter = egress_filter if egress_filter is not None else ''
638        '''
639         A filter applied to the routing logic to pin datasource to nodes.
640        '''
641        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
642        '''
643         The path used to check the health of your connection.  Defaults to `default`.
644        '''
645        self.healthy = healthy if healthy is not None else False
646        '''
647         True if the datasource is reachable and the credentials are valid.
648        '''
649        self.hostname = hostname if hostname is not None else ''
650        '''
651
652        '''
653        self.id = id if id is not None else ''
654        '''
655         Unique identifier of the Resource.
656        '''
657        self.name = name if name is not None else ''
658        '''
659         Unique human-readable name of the Resource.
660        '''
661        self.port = port if port is not None else 0
662        '''
663
664        '''
665        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
666        '''
667         ID of the secret store containing credentials for this resource, if any.
668        '''
669        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
670        '''
671         Tags is a map of key, value pairs.
672        '''
673
674    def __repr__(self):
675        return '<sdm.AKSUserImpersonation ' + \
676            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
677            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
678            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
679            'client_key: ' + repr(self.client_key) + ' ' +\
680            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
681            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
682            'healthy: ' + repr(self.healthy) + ' ' +\
683            'hostname: ' + repr(self.hostname) + ' ' +\
684            'id: ' + repr(self.id) + ' ' +\
685            'name: ' + repr(self.name) + ' ' +\
686            'port: ' + repr(self.port) + ' ' +\
687            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
688            'tags: ' + repr(self.tags) + ' ' +\
689            '>'
690
691    def to_dict(self):
692        return {
693            'bind_interface': self.bind_interface,
694            'certificate_authority': self.certificate_authority,
695            'client_certificate': self.client_certificate,
696            'client_key': self.client_key,
697            'egress_filter': self.egress_filter,
698            'healthcheck_namespace': self.healthcheck_namespace,
699            'healthy': self.healthy,
700            'hostname': self.hostname,
701            'id': self.id,
702            'name': self.name,
703            'port': self.port,
704            'secret_store_id': self.secret_store_id,
705            'tags': self.tags,
706        }
707
708    @classmethod
709    def from_dict(cls, d):
710        return cls(
711            bind_interface=d.get('bind_interface'),
712            certificate_authority=d.get('certificate_authority'),
713            client_certificate=d.get('client_certificate'),
714            client_key=d.get('client_key'),
715            egress_filter=d.get('egress_filter'),
716            healthcheck_namespace=d.get('healthcheck_namespace'),
717            healthy=d.get('healthy'),
718            hostname=d.get('hostname'),
719            id=d.get('id'),
720            name=d.get('name'),
721            port=d.get('port'),
722            secret_store_id=d.get('secret_store_id'),
723            tags=d.get('tags'),
724        )
AKSUserImpersonation( bind_interface=None, certificate_authority=None, client_certificate=None, client_key=None, egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, port=None, secret_store_id=None, tags=None)
605    def __init__(
606        self,
607        bind_interface=None,
608        certificate_authority=None,
609        client_certificate=None,
610        client_key=None,
611        egress_filter=None,
612        healthcheck_namespace=None,
613        healthy=None,
614        hostname=None,
615        id=None,
616        name=None,
617        port=None,
618        secret_store_id=None,
619        tags=None,
620    ):
621        self.bind_interface = bind_interface if bind_interface is not None else ''
622        '''
623         Bind interface
624        '''
625        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
626        '''
627
628        '''
629        self.client_certificate = client_certificate if client_certificate is not None else ''
630        '''
631
632        '''
633        self.client_key = client_key if client_key is not None else ''
634        '''
635
636        '''
637        self.egress_filter = egress_filter if egress_filter is not None else ''
638        '''
639         A filter applied to the routing logic to pin datasource to nodes.
640        '''
641        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
642        '''
643         The path used to check the health of your connection.  Defaults to `default`.
644        '''
645        self.healthy = healthy if healthy is not None else False
646        '''
647         True if the datasource is reachable and the credentials are valid.
648        '''
649        self.hostname = hostname if hostname is not None else ''
650        '''
651
652        '''
653        self.id = id if id is not None else ''
654        '''
655         Unique identifier of the Resource.
656        '''
657        self.name = name if name is not None else ''
658        '''
659         Unique human-readable name of the Resource.
660        '''
661        self.port = port if port is not None else 0
662        '''
663
664        '''
665        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
666        '''
667         ID of the secret store containing credentials for this resource, if any.
668        '''
669        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
670        '''
671         Tags is a map of key, value pairs.
672        '''
bind_interface

Bind interface

certificate_authority
client_certificate
client_key
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
691    def to_dict(self):
692        return {
693            'bind_interface': self.bind_interface,
694            'certificate_authority': self.certificate_authority,
695            'client_certificate': self.client_certificate,
696            'client_key': self.client_key,
697            'egress_filter': self.egress_filter,
698            'healthcheck_namespace': self.healthcheck_namespace,
699            'healthy': self.healthy,
700            'hostname': self.hostname,
701            'id': self.id,
702            'name': self.name,
703            'port': self.port,
704            'secret_store_id': self.secret_store_id,
705            'tags': self.tags,
706        }
@classmethod
def from_dict(cls, d)
708    @classmethod
709    def from_dict(cls, d):
710        return cls(
711            bind_interface=d.get('bind_interface'),
712            certificate_authority=d.get('certificate_authority'),
713            client_certificate=d.get('client_certificate'),
714            client_key=d.get('client_key'),
715            egress_filter=d.get('egress_filter'),
716            healthcheck_namespace=d.get('healthcheck_namespace'),
717            healthy=d.get('healthy'),
718            hostname=d.get('hostname'),
719            id=d.get('id'),
720            name=d.get('name'),
721            port=d.get('port'),
722            secret_store_id=d.get('secret_store_id'),
723            tags=d.get('tags'),
724        )
class AWS:
727class AWS:
728    '''
729
730    '''
731    __slots__ = [
732        'access_key',
733        'bind_interface',
734        'egress_filter',
735        'healthcheck_region',
736        'healthy',
737        'id',
738        'name',
739        'role_arn',
740        'role_external_id',
741        'secret_access_key',
742        'secret_store_id',
743        'tags',
744    ]
745
746    def __init__(
747        self,
748        access_key=None,
749        bind_interface=None,
750        egress_filter=None,
751        healthcheck_region=None,
752        healthy=None,
753        id=None,
754        name=None,
755        role_arn=None,
756        role_external_id=None,
757        secret_access_key=None,
758        secret_store_id=None,
759        tags=None,
760    ):
761        self.access_key = access_key if access_key is not None else ''
762        '''
763
764        '''
765        self.bind_interface = bind_interface if bind_interface is not None else ''
766        '''
767         Bind interface
768        '''
769        self.egress_filter = egress_filter if egress_filter is not None else ''
770        '''
771         A filter applied to the routing logic to pin datasource to nodes.
772        '''
773        self.healthcheck_region = healthcheck_region if healthcheck_region is not None else ''
774        '''
775
776        '''
777        self.healthy = healthy if healthy is not None else False
778        '''
779         True if the datasource is reachable and the credentials are valid.
780        '''
781        self.id = id if id is not None else ''
782        '''
783         Unique identifier of the Resource.
784        '''
785        self.name = name if name is not None else ''
786        '''
787         Unique human-readable name of the Resource.
788        '''
789        self.role_arn = role_arn if role_arn is not None else ''
790        '''
791
792        '''
793        self.role_external_id = role_external_id if role_external_id is not None else ''
794        '''
795
796        '''
797        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
798        '''
799
800        '''
801        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
802        '''
803         ID of the secret store containing credentials for this resource, if any.
804        '''
805        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
806        '''
807         Tags is a map of key, value pairs.
808        '''
809
810    def __repr__(self):
811        return '<sdm.AWS ' + \
812            'access_key: ' + repr(self.access_key) + ' ' +\
813            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
814            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
815            'healthcheck_region: ' + repr(self.healthcheck_region) + ' ' +\
816            'healthy: ' + repr(self.healthy) + ' ' +\
817            'id: ' + repr(self.id) + ' ' +\
818            'name: ' + repr(self.name) + ' ' +\
819            'role_arn: ' + repr(self.role_arn) + ' ' +\
820            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
821            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
822            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
823            'tags: ' + repr(self.tags) + ' ' +\
824            '>'
825
826    def to_dict(self):
827        return {
828            'access_key': self.access_key,
829            'bind_interface': self.bind_interface,
830            'egress_filter': self.egress_filter,
831            'healthcheck_region': self.healthcheck_region,
832            'healthy': self.healthy,
833            'id': self.id,
834            'name': self.name,
835            'role_arn': self.role_arn,
836            'role_external_id': self.role_external_id,
837            'secret_access_key': self.secret_access_key,
838            'secret_store_id': self.secret_store_id,
839            'tags': self.tags,
840        }
841
842    @classmethod
843    def from_dict(cls, d):
844        return cls(
845            access_key=d.get('access_key'),
846            bind_interface=d.get('bind_interface'),
847            egress_filter=d.get('egress_filter'),
848            healthcheck_region=d.get('healthcheck_region'),
849            healthy=d.get('healthy'),
850            id=d.get('id'),
851            name=d.get('name'),
852            role_arn=d.get('role_arn'),
853            role_external_id=d.get('role_external_id'),
854            secret_access_key=d.get('secret_access_key'),
855            secret_store_id=d.get('secret_store_id'),
856            tags=d.get('tags'),
857        )
AWS( access_key=None, bind_interface=None, egress_filter=None, healthcheck_region=None, healthy=None, id=None, name=None, role_arn=None, role_external_id=None, secret_access_key=None, secret_store_id=None, tags=None)
746    def __init__(
747        self,
748        access_key=None,
749        bind_interface=None,
750        egress_filter=None,
751        healthcheck_region=None,
752        healthy=None,
753        id=None,
754        name=None,
755        role_arn=None,
756        role_external_id=None,
757        secret_access_key=None,
758        secret_store_id=None,
759        tags=None,
760    ):
761        self.access_key = access_key if access_key is not None else ''
762        '''
763
764        '''
765        self.bind_interface = bind_interface if bind_interface is not None else ''
766        '''
767         Bind interface
768        '''
769        self.egress_filter = egress_filter if egress_filter is not None else ''
770        '''
771         A filter applied to the routing logic to pin datasource to nodes.
772        '''
773        self.healthcheck_region = healthcheck_region if healthcheck_region is not None else ''
774        '''
775
776        '''
777        self.healthy = healthy if healthy is not None else False
778        '''
779         True if the datasource is reachable and the credentials are valid.
780        '''
781        self.id = id if id is not None else ''
782        '''
783         Unique identifier of the Resource.
784        '''
785        self.name = name if name is not None else ''
786        '''
787         Unique human-readable name of the Resource.
788        '''
789        self.role_arn = role_arn if role_arn is not None else ''
790        '''
791
792        '''
793        self.role_external_id = role_external_id if role_external_id is not None else ''
794        '''
795
796        '''
797        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
798        '''
799
800        '''
801        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
802        '''
803         ID of the secret store containing credentials for this resource, if any.
804        '''
805        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
806        '''
807         Tags is a map of key, value pairs.
808        '''
access_key
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthcheck_region
healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

role_arn
role_external_id
secret_access_key
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
826    def to_dict(self):
827        return {
828            'access_key': self.access_key,
829            'bind_interface': self.bind_interface,
830            'egress_filter': self.egress_filter,
831            'healthcheck_region': self.healthcheck_region,
832            'healthy': self.healthy,
833            'id': self.id,
834            'name': self.name,
835            'role_arn': self.role_arn,
836            'role_external_id': self.role_external_id,
837            'secret_access_key': self.secret_access_key,
838            'secret_store_id': self.secret_store_id,
839            'tags': self.tags,
840        }
@classmethod
def from_dict(cls, d)
842    @classmethod
843    def from_dict(cls, d):
844        return cls(
845            access_key=d.get('access_key'),
846            bind_interface=d.get('bind_interface'),
847            egress_filter=d.get('egress_filter'),
848            healthcheck_region=d.get('healthcheck_region'),
849            healthy=d.get('healthy'),
850            id=d.get('id'),
851            name=d.get('name'),
852            role_arn=d.get('role_arn'),
853            role_external_id=d.get('role_external_id'),
854            secret_access_key=d.get('secret_access_key'),
855            secret_store_id=d.get('secret_store_id'),
856            tags=d.get('tags'),
857        )
class AWSStore:
860class AWSStore:
861    '''
862
863    '''
864    __slots__ = [
865        'id',
866        'name',
867        'region',
868        'tags',
869    ]
870
871    def __init__(
872        self,
873        id=None,
874        name=None,
875        region=None,
876        tags=None,
877    ):
878        self.id = id if id is not None else ''
879        '''
880         Unique identifier of the SecretStore.
881        '''
882        self.name = name if name is not None else ''
883        '''
884         Unique human-readable name of the SecretStore.
885        '''
886        self.region = region if region is not None else ''
887        '''
888
889        '''
890        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
891        '''
892         Tags is a map of key, value pairs.
893        '''
894
895    def __repr__(self):
896        return '<sdm.AWSStore ' + \
897            'id: ' + repr(self.id) + ' ' +\
898            'name: ' + repr(self.name) + ' ' +\
899            'region: ' + repr(self.region) + ' ' +\
900            'tags: ' + repr(self.tags) + ' ' +\
901            '>'
902
903    def to_dict(self):
904        return {
905            'id': self.id,
906            'name': self.name,
907            'region': self.region,
908            'tags': self.tags,
909        }
910
911    @classmethod
912    def from_dict(cls, d):
913        return cls(
914            id=d.get('id'),
915            name=d.get('name'),
916            region=d.get('region'),
917            tags=d.get('tags'),
918        )
AWSStore(id=None, name=None, region=None, tags=None)
871    def __init__(
872        self,
873        id=None,
874        name=None,
875        region=None,
876        tags=None,
877    ):
878        self.id = id if id is not None else ''
879        '''
880         Unique identifier of the SecretStore.
881        '''
882        self.name = name if name is not None else ''
883        '''
884         Unique human-readable name of the SecretStore.
885        '''
886        self.region = region if region is not None else ''
887        '''
888
889        '''
890        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
891        '''
892         Tags is a map of key, value pairs.
893        '''
id

Unique identifier of the SecretStore.

name

Unique human-readable name of the SecretStore.

region
tags

Tags is a map of key, value pairs.

def to_dict(self)
903    def to_dict(self):
904        return {
905            'id': self.id,
906            'name': self.name,
907            'region': self.region,
908            'tags': self.tags,
909        }
@classmethod
def from_dict(cls, d)
911    @classmethod
912    def from_dict(cls, d):
913        return cls(
914            id=d.get('id'),
915            name=d.get('name'),
916            region=d.get('region'),
917            tags=d.get('tags'),
918        )
class AccountAttachment:
921class AccountAttachment:
922    '''
923     AccountAttachments assign an account to a role.
924    '''
925    __slots__ = [
926        'account_id',
927        'id',
928        'role_id',
929    ]
930
931    def __init__(
932        self,
933        account_id=None,
934        id=None,
935        role_id=None,
936    ):
937        self.account_id = account_id if account_id is not None else ''
938        '''
939         The id of the account of this AccountAttachment.
940        '''
941        self.id = id if id is not None else ''
942        '''
943         Unique identifier of the AccountAttachment.
944        '''
945        self.role_id = role_id if role_id is not None else ''
946        '''
947         The id of the attached role of this AccountAttachment.
948        '''
949
950    def __repr__(self):
951        return '<sdm.AccountAttachment ' + \
952            'account_id: ' + repr(self.account_id) + ' ' +\
953            'id: ' + repr(self.id) + ' ' +\
954            'role_id: ' + repr(self.role_id) + ' ' +\
955            '>'
956
957    def to_dict(self):
958        return {
959            'account_id': self.account_id,
960            'id': self.id,
961            'role_id': self.role_id,
962        }
963
964    @classmethod
965    def from_dict(cls, d):
966        return cls(
967            account_id=d.get('account_id'),
968            id=d.get('id'),
969            role_id=d.get('role_id'),
970        )

AccountAttachments assign an account to a role.

AccountAttachment(account_id=None, id=None, role_id=None)
931    def __init__(
932        self,
933        account_id=None,
934        id=None,
935        role_id=None,
936    ):
937        self.account_id = account_id if account_id is not None else ''
938        '''
939         The id of the account of this AccountAttachment.
940        '''
941        self.id = id if id is not None else ''
942        '''
943         Unique identifier of the AccountAttachment.
944        '''
945        self.role_id = role_id if role_id is not None else ''
946        '''
947         The id of the attached role of this AccountAttachment.
948        '''
account_id

The id of the account of this AccountAttachment.

id

Unique identifier of the AccountAttachment.

role_id

The id of the attached role of this AccountAttachment.

def to_dict(self)
957    def to_dict(self):
958        return {
959            'account_id': self.account_id,
960            'id': self.id,
961            'role_id': self.role_id,
962        }
@classmethod
def from_dict(cls, d)
964    @classmethod
965    def from_dict(cls, d):
966        return cls(
967            account_id=d.get('account_id'),
968            id=d.get('id'),
969            role_id=d.get('role_id'),
970        )
class AccountAttachmentCreateResponse:
 973class AccountAttachmentCreateResponse:
 974    '''
 975     AccountAttachmentCreateResponse reports how the AccountAttachments were created in the system.
 976    '''
 977    __slots__ = [
 978        'account_attachment',
 979        'meta',
 980        'rate_limit',
 981    ]
 982
 983    def __init__(
 984        self,
 985        account_attachment=None,
 986        meta=None,
 987        rate_limit=None,
 988    ):
 989        self.account_attachment = account_attachment if account_attachment is not None else None
 990        '''
 991         The created AccountAttachment.
 992        '''
 993        self.meta = meta if meta is not None else None
 994        '''
 995         Reserved for future use.
 996        '''
 997        self.rate_limit = rate_limit if rate_limit is not None else None
 998        '''
 999         Rate limit information.
1000        '''
1001
1002    def __repr__(self):
1003        return '<sdm.AccountAttachmentCreateResponse ' + \
1004            'account_attachment: ' + repr(self.account_attachment) + ' ' +\
1005            'meta: ' + repr(self.meta) + ' ' +\
1006            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
1007            '>'
1008
1009    def to_dict(self):
1010        return {
1011            'account_attachment': self.account_attachment,
1012            'meta': self.meta,
1013            'rate_limit': self.rate_limit,
1014        }
1015
1016    @classmethod
1017    def from_dict(cls, d):
1018        return cls(
1019            account_attachment=d.get('account_attachment'),
1020            meta=d.get('meta'),
1021            rate_limit=d.get('rate_limit'),
1022        )

AccountAttachmentCreateResponse reports how the AccountAttachments were created in the system.

AccountAttachmentCreateResponse(account_attachment=None, meta=None, rate_limit=None)
 983    def __init__(
 984        self,
 985        account_attachment=None,
 986        meta=None,
 987        rate_limit=None,
 988    ):
 989        self.account_attachment = account_attachment if account_attachment is not None else None
 990        '''
 991         The created AccountAttachment.
 992        '''
 993        self.meta = meta if meta is not None else None
 994        '''
 995         Reserved for future use.
 996        '''
 997        self.rate_limit = rate_limit if rate_limit is not None else None
 998        '''
 999         Rate limit information.
1000        '''
account_attachment

The created AccountAttachment.

meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
1009    def to_dict(self):
1010        return {
1011            'account_attachment': self.account_attachment,
1012            'meta': self.meta,
1013            'rate_limit': self.rate_limit,
1014        }
@classmethod
def from_dict(cls, d)
1016    @classmethod
1017    def from_dict(cls, d):
1018        return cls(
1019            account_attachment=d.get('account_attachment'),
1020            meta=d.get('meta'),
1021            rate_limit=d.get('rate_limit'),
1022        )
class AccountAttachmentDeleteResponse:
1025class AccountAttachmentDeleteResponse:
1026    '''
1027     AccountAttachmentDeleteResponse returns information about a AccountAttachment that was deleted.
1028    '''
1029    __slots__ = [
1030        'meta',
1031        'rate_limit',
1032    ]
1033
1034    def __init__(
1035        self,
1036        meta=None,
1037        rate_limit=None,
1038    ):
1039        self.meta = meta if meta is not None else None
1040        '''
1041         Reserved for future use.
1042        '''
1043        self.rate_limit = rate_limit if rate_limit is not None else None
1044        '''
1045         Rate limit information.
1046        '''
1047
1048    def __repr__(self):
1049        return '<sdm.AccountAttachmentDeleteResponse ' + \
1050            'meta: ' + repr(self.meta) + ' ' +\
1051            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
1052            '>'
1053
1054    def to_dict(self):
1055        return {
1056            'meta': self.meta,
1057            'rate_limit': self.rate_limit,
1058        }
1059
1060    @classmethod
1061    def from_dict(cls, d):
1062        return cls(
1063            meta=d.get('meta'),
1064            rate_limit=d.get('rate_limit'),
1065        )

AccountAttachmentDeleteResponse returns information about a AccountAttachment that was deleted.

AccountAttachmentDeleteResponse(meta=None, rate_limit=None)
1034    def __init__(
1035        self,
1036        meta=None,
1037        rate_limit=None,
1038    ):
1039        self.meta = meta if meta is not None else None
1040        '''
1041         Reserved for future use.
1042        '''
1043        self.rate_limit = rate_limit if rate_limit is not None else None
1044        '''
1045         Rate limit information.
1046        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
1054    def to_dict(self):
1055        return {
1056            'meta': self.meta,
1057            'rate_limit': self.rate_limit,
1058        }
@classmethod
def from_dict(cls, d)
1060    @classmethod
1061    def from_dict(cls, d):
1062        return cls(
1063            meta=d.get('meta'),
1064            rate_limit=d.get('rate_limit'),
1065        )
class AccountAttachmentGetResponse:
1068class AccountAttachmentGetResponse:
1069    '''
1070     AccountAttachmentGetResponse returns a requested AccountAttachment.
1071    '''
1072    __slots__ = [
1073        'account_attachment',
1074        'meta',
1075        'rate_limit',
1076    ]
1077
1078    def __init__(
1079        self,
1080        account_attachment=None,
1081        meta=None,
1082        rate_limit=None,
1083    ):
1084        self.account_attachment = account_attachment if account_attachment is not None else None
1085        '''
1086         The requested AccountAttachment.
1087        '''
1088        self.meta = meta if meta is not None else None
1089        '''
1090         Reserved for future use.
1091        '''
1092        self.rate_limit = rate_limit if rate_limit is not None else None
1093        '''
1094         Rate limit information.
1095        '''
1096
1097    def __repr__(self):
1098        return '<sdm.AccountAttachmentGetResponse ' + \
1099            'account_attachment: ' + repr(self.account_attachment) + ' ' +\
1100            'meta: ' + repr(self.meta) + ' ' +\
1101            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
1102            '>'
1103
1104    def to_dict(self):
1105        return {
1106            'account_attachment': self.account_attachment,
1107            'meta': self.meta,
1108            'rate_limit': self.rate_limit,
1109        }
1110
1111    @classmethod
1112    def from_dict(cls, d):
1113        return cls(
1114            account_attachment=d.get('account_attachment'),
1115            meta=d.get('meta'),
1116            rate_limit=d.get('rate_limit'),
1117        )

AccountAttachmentGetResponse returns a requested AccountAttachment.

AccountAttachmentGetResponse(account_attachment=None, meta=None, rate_limit=None)
1078    def __init__(
1079        self,
1080        account_attachment=None,
1081        meta=None,
1082        rate_limit=None,
1083    ):
1084        self.account_attachment = account_attachment if account_attachment is not None else None
1085        '''
1086         The requested AccountAttachment.
1087        '''
1088        self.meta = meta if meta is not None else None
1089        '''
1090         Reserved for future use.
1091        '''
1092        self.rate_limit = rate_limit if rate_limit is not None else None
1093        '''
1094         Rate limit information.
1095        '''
account_attachment

The requested AccountAttachment.

meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
1104    def to_dict(self):
1105        return {
1106            'account_attachment': self.account_attachment,
1107            'meta': self.meta,
1108            'rate_limit': self.rate_limit,
1109        }
@classmethod
def from_dict(cls, d)
1111    @classmethod
1112    def from_dict(cls, d):
1113        return cls(
1114            account_attachment=d.get('account_attachment'),
1115            meta=d.get('meta'),
1116            rate_limit=d.get('rate_limit'),
1117        )
class AccountCreateResponse:
1120class AccountCreateResponse:
1121    '''
1122     AccountCreateResponse reports how the Accounts were created in the system.
1123    '''
1124    __slots__ = [
1125        'account',
1126        'meta',
1127        'rate_limit',
1128        'token',
1129    ]
1130
1131    def __init__(
1132        self,
1133        account=None,
1134        meta=None,
1135        rate_limit=None,
1136        token=None,
1137    ):
1138        self.account = account if account is not None else None
1139        '''
1140         The created Account.
1141        '''
1142        self.meta = meta if meta is not None else None
1143        '''
1144         Reserved for future use.
1145        '''
1146        self.rate_limit = rate_limit if rate_limit is not None else None
1147        '''
1148         Rate limit information.
1149        '''
1150        self.token = token if token is not None else ''
1151        '''
1152         The auth token generated for the Account. The Account will use this token to
1153         authenticate with the strongDM API.
1154        '''
1155
1156    def __repr__(self):
1157        return '<sdm.AccountCreateResponse ' + \
1158            'account: ' + repr(self.account) + ' ' +\
1159            'meta: ' + repr(self.meta) + ' ' +\
1160            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
1161            'token: ' + repr(self.token) + ' ' +\
1162            '>'
1163
1164    def to_dict(self):
1165        return {
1166            'account': self.account,
1167            'meta': self.meta,
1168            'rate_limit': self.rate_limit,
1169            'token': self.token,
1170        }
1171
1172    @classmethod
1173    def from_dict(cls, d):
1174        return cls(
1175            account=d.get('account'),
1176            meta=d.get('meta'),
1177            rate_limit=d.get('rate_limit'),
1178            token=d.get('token'),
1179        )

AccountCreateResponse reports how the Accounts were created in the system.

AccountCreateResponse(account=None, meta=None, rate_limit=None, token=None)
1131    def __init__(
1132        self,
1133        account=None,
1134        meta=None,
1135        rate_limit=None,
1136        token=None,
1137    ):
1138        self.account = account if account is not None else None
1139        '''
1140         The created Account.
1141        '''
1142        self.meta = meta if meta is not None else None
1143        '''
1144         Reserved for future use.
1145        '''
1146        self.rate_limit = rate_limit if rate_limit is not None else None
1147        '''
1148         Rate limit information.
1149        '''
1150        self.token = token if token is not None else ''
1151        '''
1152         The auth token generated for the Account. The Account will use this token to
1153         authenticate with the strongDM API.
1154        '''
account

The created Account.

meta

Reserved for future use.

rate_limit

Rate limit information.

token

The auth token generated for the Account. The Account will use this token to authenticate with the strongDM API.

def to_dict(self)
1164    def to_dict(self):
1165        return {
1166            'account': self.account,
1167            'meta': self.meta,
1168            'rate_limit': self.rate_limit,
1169            'token': self.token,
1170        }
@classmethod
def from_dict(cls, d)
1172    @classmethod
1173    def from_dict(cls, d):
1174        return cls(
1175            account=d.get('account'),
1176            meta=d.get('meta'),
1177            rate_limit=d.get('rate_limit'),
1178            token=d.get('token'),
1179        )
class AccountDeleteResponse:
1182class AccountDeleteResponse:
1183    '''
1184     AccountDeleteResponse returns information about a Account that was deleted.
1185    '''
1186    __slots__ = [
1187        'meta',
1188        'rate_limit',
1189    ]
1190
1191    def __init__(
1192        self,
1193        meta=None,
1194        rate_limit=None,
1195    ):
1196        self.meta = meta if meta is not None else None
1197        '''
1198         Reserved for future use.
1199        '''
1200        self.rate_limit = rate_limit if rate_limit is not None else None
1201        '''
1202         Rate limit information.
1203        '''
1204
1205    def __repr__(self):
1206        return '<sdm.AccountDeleteResponse ' + \
1207            'meta: ' + repr(self.meta) + ' ' +\
1208            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
1209            '>'
1210
1211    def to_dict(self):
1212        return {
1213            'meta': self.meta,
1214            'rate_limit': self.rate_limit,
1215        }
1216
1217    @classmethod
1218    def from_dict(cls, d):
1219        return cls(
1220            meta=d.get('meta'),
1221            rate_limit=d.get('rate_limit'),
1222        )

AccountDeleteResponse returns information about a Account that was deleted.

AccountDeleteResponse(meta=None, rate_limit=None)
1191    def __init__(
1192        self,
1193        meta=None,
1194        rate_limit=None,
1195    ):
1196        self.meta = meta if meta is not None else None
1197        '''
1198         Reserved for future use.
1199        '''
1200        self.rate_limit = rate_limit if rate_limit is not None else None
1201        '''
1202         Rate limit information.
1203        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
1211    def to_dict(self):
1212        return {
1213            'meta': self.meta,
1214            'rate_limit': self.rate_limit,
1215        }
@classmethod
def from_dict(cls, d)
1217    @classmethod
1218    def from_dict(cls, d):
1219        return cls(
1220            meta=d.get('meta'),
1221            rate_limit=d.get('rate_limit'),
1222        )
class AccountGetResponse:
1225class AccountGetResponse:
1226    '''
1227     AccountGetResponse returns a requested Account.
1228    '''
1229    __slots__ = [
1230        'account',
1231        'meta',
1232        'rate_limit',
1233    ]
1234
1235    def __init__(
1236        self,
1237        account=None,
1238        meta=None,
1239        rate_limit=None,
1240    ):
1241        self.account = account if account is not None else None
1242        '''
1243         The requested Account.
1244        '''
1245        self.meta = meta if meta is not None else None
1246        '''
1247         Reserved for future use.
1248        '''
1249        self.rate_limit = rate_limit if rate_limit is not None else None
1250        '''
1251         Rate limit information.
1252        '''
1253
1254    def __repr__(self):
1255        return '<sdm.AccountGetResponse ' + \
1256            'account: ' + repr(self.account) + ' ' +\
1257            'meta: ' + repr(self.meta) + ' ' +\
1258            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
1259            '>'
1260
1261    def to_dict(self):
1262        return {
1263            'account': self.account,
1264            'meta': self.meta,
1265            'rate_limit': self.rate_limit,
1266        }
1267
1268    @classmethod
1269    def from_dict(cls, d):
1270        return cls(
1271            account=d.get('account'),
1272            meta=d.get('meta'),
1273            rate_limit=d.get('rate_limit'),
1274        )

AccountGetResponse returns a requested Account.

AccountGetResponse(account=None, meta=None, rate_limit=None)
1235    def __init__(
1236        self,
1237        account=None,
1238        meta=None,
1239        rate_limit=None,
1240    ):
1241        self.account = account if account is not None else None
1242        '''
1243         The requested Account.
1244        '''
1245        self.meta = meta if meta is not None else None
1246        '''
1247         Reserved for future use.
1248        '''
1249        self.rate_limit = rate_limit if rate_limit is not None else None
1250        '''
1251         Rate limit information.
1252        '''
account

The requested Account.

meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
1261    def to_dict(self):
1262        return {
1263            'account': self.account,
1264            'meta': self.meta,
1265            'rate_limit': self.rate_limit,
1266        }
@classmethod
def from_dict(cls, d)
1268    @classmethod
1269    def from_dict(cls, d):
1270        return cls(
1271            account=d.get('account'),
1272            meta=d.get('meta'),
1273            rate_limit=d.get('rate_limit'),
1274        )
class AccountGrant:
1277class AccountGrant:
1278    '''
1279     AccountGrants connect a resource directly to an account, giving the account the permission to connect to that resource.
1280    '''
1281    __slots__ = [
1282        'account_id',
1283        'id',
1284        'resource_id',
1285        'start_from',
1286        'valid_until',
1287    ]
1288
1289    def __init__(
1290        self,
1291        account_id=None,
1292        id=None,
1293        resource_id=None,
1294        start_from=None,
1295        valid_until=None,
1296    ):
1297        self.account_id = account_id if account_id is not None else ''
1298        '''
1299         The account id of this AccountGrant.
1300        '''
1301        self.id = id if id is not None else ''
1302        '''
1303         Unique identifier of the AccountGrant.
1304        '''
1305        self.resource_id = resource_id if resource_id is not None else ''
1306        '''
1307         The resource id of this AccountGrant.
1308        '''
1309        self.start_from = start_from if start_from is not None else None
1310        '''
1311         The timestamp when the resource will be granted. Optional. Both start_at
1312         and end_at must be defined together, or not defined at all.
1313        '''
1314        self.valid_until = valid_until if valid_until is not None else None
1315        '''
1316         The timestamp when the resource grant will expire. Optional. Both
1317         start_at and end_at must be defined together, or not defined at all.
1318        '''
1319
1320    def __repr__(self):
1321        return '<sdm.AccountGrant ' + \
1322            'account_id: ' + repr(self.account_id) + ' ' +\
1323            'id: ' + repr(self.id) + ' ' +\
1324            'resource_id: ' + repr(self.resource_id) + ' ' +\
1325            'start_from: ' + repr(self.start_from) + ' ' +\
1326            'valid_until: ' + repr(self.valid_until) + ' ' +\
1327            '>'
1328
1329    def to_dict(self):
1330        return {
1331            'account_id': self.account_id,
1332            'id': self.id,
1333            'resource_id': self.resource_id,
1334            'start_from': self.start_from,
1335            'valid_until': self.valid_until,
1336        }
1337
1338    @classmethod
1339    def from_dict(cls, d):
1340        return cls(
1341            account_id=d.get('account_id'),
1342            id=d.get('id'),
1343            resource_id=d.get('resource_id'),
1344            start_from=d.get('start_from'),
1345            valid_until=d.get('valid_until'),
1346        )

AccountGrants connect a resource directly to an account, giving the account the permission to connect to that resource.

AccountGrant( account_id=None, id=None, resource_id=None, start_from=None, valid_until=None)
1289    def __init__(
1290        self,
1291        account_id=None,
1292        id=None,
1293        resource_id=None,
1294        start_from=None,
1295        valid_until=None,
1296    ):
1297        self.account_id = account_id if account_id is not None else ''
1298        '''
1299         The account id of this AccountGrant.
1300        '''
1301        self.id = id if id is not None else ''
1302        '''
1303         Unique identifier of the AccountGrant.
1304        '''
1305        self.resource_id = resource_id if resource_id is not None else ''
1306        '''
1307         The resource id of this AccountGrant.
1308        '''
1309        self.start_from = start_from if start_from is not None else None
1310        '''
1311         The timestamp when the resource will be granted. Optional. Both start_at
1312         and end_at must be defined together, or not defined at all.
1313        '''
1314        self.valid_until = valid_until if valid_until is not None else None
1315        '''
1316         The timestamp when the resource grant will expire. Optional. Both
1317         start_at and end_at must be defined together, or not defined at all.
1318        '''
account_id

The account id of this AccountGrant.

id

Unique identifier of the AccountGrant.

resource_id

The resource id of this AccountGrant.

start_from

The timestamp when the resource will be granted. Optional. Both start_at and end_at must be defined together, or not defined at all.

valid_until

The timestamp when the resource grant will expire. Optional. Both start_at and end_at must be defined together, or not defined at all.

def to_dict(self)
1329    def to_dict(self):
1330        return {
1331            'account_id': self.account_id,
1332            'id': self.id,
1333            'resource_id': self.resource_id,
1334            'start_from': self.start_from,
1335            'valid_until': self.valid_until,
1336        }
@classmethod
def from_dict(cls, d)
1338    @classmethod
1339    def from_dict(cls, d):
1340        return cls(
1341            account_id=d.get('account_id'),
1342            id=d.get('id'),
1343            resource_id=d.get('resource_id'),
1344            start_from=d.get('start_from'),
1345            valid_until=d.get('valid_until'),
1346        )
class AccountGrantCreateResponse:
1349class AccountGrantCreateResponse:
1350    '''
1351     AccountGrantCreateResponse reports how the AccountGrants were created in the system.
1352    '''
1353    __slots__ = [
1354        'account_grant',
1355        'meta',
1356        'rate_limit',
1357    ]
1358
1359    def __init__(
1360        self,
1361        account_grant=None,
1362        meta=None,
1363        rate_limit=None,
1364    ):
1365        self.account_grant = account_grant if account_grant is not None else None
1366        '''
1367         The created AccountGrant.
1368        '''
1369        self.meta = meta if meta is not None else None
1370        '''
1371         Reserved for future use.
1372        '''
1373        self.rate_limit = rate_limit if rate_limit is not None else None
1374        '''
1375         Rate limit information.
1376        '''
1377
1378    def __repr__(self):
1379        return '<sdm.AccountGrantCreateResponse ' + \
1380            'account_grant: ' + repr(self.account_grant) + ' ' +\
1381            'meta: ' + repr(self.meta) + ' ' +\
1382            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
1383            '>'
1384
1385    def to_dict(self):
1386        return {
1387            'account_grant': self.account_grant,
1388            'meta': self.meta,
1389            'rate_limit': self.rate_limit,
1390        }
1391
1392    @classmethod
1393    def from_dict(cls, d):
1394        return cls(
1395            account_grant=d.get('account_grant'),
1396            meta=d.get('meta'),
1397            rate_limit=d.get('rate_limit'),
1398        )

AccountGrantCreateResponse reports how the AccountGrants were created in the system.

AccountGrantCreateResponse(account_grant=None, meta=None, rate_limit=None)
1359    def __init__(
1360        self,
1361        account_grant=None,
1362        meta=None,
1363        rate_limit=None,
1364    ):
1365        self.account_grant = account_grant if account_grant is not None else None
1366        '''
1367         The created AccountGrant.
1368        '''
1369        self.meta = meta if meta is not None else None
1370        '''
1371         Reserved for future use.
1372        '''
1373        self.rate_limit = rate_limit if rate_limit is not None else None
1374        '''
1375         Rate limit information.
1376        '''
account_grant

The created AccountGrant.

meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
1385    def to_dict(self):
1386        return {
1387            'account_grant': self.account_grant,
1388            'meta': self.meta,
1389            'rate_limit': self.rate_limit,
1390        }
@classmethod
def from_dict(cls, d)
1392    @classmethod
1393    def from_dict(cls, d):
1394        return cls(
1395            account_grant=d.get('account_grant'),
1396            meta=d.get('meta'),
1397            rate_limit=d.get('rate_limit'),
1398        )
class AccountGrantDeleteResponse:
1401class AccountGrantDeleteResponse:
1402    '''
1403     AccountGrantDeleteResponse returns information about a AccountGrant that was deleted.
1404    '''
1405    __slots__ = [
1406        'meta',
1407        'rate_limit',
1408    ]
1409
1410    def __init__(
1411        self,
1412        meta=None,
1413        rate_limit=None,
1414    ):
1415        self.meta = meta if meta is not None else None
1416        '''
1417         Reserved for future use.
1418        '''
1419        self.rate_limit = rate_limit if rate_limit is not None else None
1420        '''
1421         Rate limit information.
1422        '''
1423
1424    def __repr__(self):
1425        return '<sdm.AccountGrantDeleteResponse ' + \
1426            'meta: ' + repr(self.meta) + ' ' +\
1427            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
1428            '>'
1429
1430    def to_dict(self):
1431        return {
1432            'meta': self.meta,
1433            'rate_limit': self.rate_limit,
1434        }
1435
1436    @classmethod
1437    def from_dict(cls, d):
1438        return cls(
1439            meta=d.get('meta'),
1440            rate_limit=d.get('rate_limit'),
1441        )

AccountGrantDeleteResponse returns information about a AccountGrant that was deleted.

AccountGrantDeleteResponse(meta=None, rate_limit=None)
1410    def __init__(
1411        self,
1412        meta=None,
1413        rate_limit=None,
1414    ):
1415        self.meta = meta if meta is not None else None
1416        '''
1417         Reserved for future use.
1418        '''
1419        self.rate_limit = rate_limit if rate_limit is not None else None
1420        '''
1421         Rate limit information.
1422        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
1430    def to_dict(self):
1431        return {
1432            'meta': self.meta,
1433            'rate_limit': self.rate_limit,
1434        }
@classmethod
def from_dict(cls, d)
1436    @classmethod
1437    def from_dict(cls, d):
1438        return cls(
1439            meta=d.get('meta'),
1440            rate_limit=d.get('rate_limit'),
1441        )
class AccountGrantGetResponse:
1444class AccountGrantGetResponse:
1445    '''
1446     AccountGrantGetResponse returns a requested AccountGrant.
1447    '''
1448    __slots__ = [
1449        'account_grant',
1450        'meta',
1451        'rate_limit',
1452    ]
1453
1454    def __init__(
1455        self,
1456        account_grant=None,
1457        meta=None,
1458        rate_limit=None,
1459    ):
1460        self.account_grant = account_grant if account_grant is not None else None
1461        '''
1462         The requested AccountGrant.
1463        '''
1464        self.meta = meta if meta is not None else None
1465        '''
1466         Reserved for future use.
1467        '''
1468        self.rate_limit = rate_limit if rate_limit is not None else None
1469        '''
1470         Rate limit information.
1471        '''
1472
1473    def __repr__(self):
1474        return '<sdm.AccountGrantGetResponse ' + \
1475            'account_grant: ' + repr(self.account_grant) + ' ' +\
1476            'meta: ' + repr(self.meta) + ' ' +\
1477            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
1478            '>'
1479
1480    def to_dict(self):
1481        return {
1482            'account_grant': self.account_grant,
1483            'meta': self.meta,
1484            'rate_limit': self.rate_limit,
1485        }
1486
1487    @classmethod
1488    def from_dict(cls, d):
1489        return cls(
1490            account_grant=d.get('account_grant'),
1491            meta=d.get('meta'),
1492            rate_limit=d.get('rate_limit'),
1493        )

AccountGrantGetResponse returns a requested AccountGrant.

AccountGrantGetResponse(account_grant=None, meta=None, rate_limit=None)
1454    def __init__(
1455        self,
1456        account_grant=None,
1457        meta=None,
1458        rate_limit=None,
1459    ):
1460        self.account_grant = account_grant if account_grant is not None else None
1461        '''
1462         The requested AccountGrant.
1463        '''
1464        self.meta = meta if meta is not None else None
1465        '''
1466         Reserved for future use.
1467        '''
1468        self.rate_limit = rate_limit if rate_limit is not None else None
1469        '''
1470         Rate limit information.
1471        '''
account_grant

The requested AccountGrant.

meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
1480    def to_dict(self):
1481        return {
1482            'account_grant': self.account_grant,
1483            'meta': self.meta,
1484            'rate_limit': self.rate_limit,
1485        }
@classmethod
def from_dict(cls, d)
1487    @classmethod
1488    def from_dict(cls, d):
1489        return cls(
1490            account_grant=d.get('account_grant'),
1491            meta=d.get('meta'),
1492            rate_limit=d.get('rate_limit'),
1493        )
class AccountUpdateResponse:
1496class AccountUpdateResponse:
1497    '''
1498     AccountUpdateResponse returns the fields of a Account after it has been updated by
1499     a AccountUpdateRequest.
1500    '''
1501    __slots__ = [
1502        'account',
1503        'meta',
1504        'rate_limit',
1505    ]
1506
1507    def __init__(
1508        self,
1509        account=None,
1510        meta=None,
1511        rate_limit=None,
1512    ):
1513        self.account = account if account is not None else None
1514        '''
1515         The updated Account.
1516        '''
1517        self.meta = meta if meta is not None else None
1518        '''
1519         Reserved for future use.
1520        '''
1521        self.rate_limit = rate_limit if rate_limit is not None else None
1522        '''
1523         Rate limit information.
1524        '''
1525
1526    def __repr__(self):
1527        return '<sdm.AccountUpdateResponse ' + \
1528            'account: ' + repr(self.account) + ' ' +\
1529            'meta: ' + repr(self.meta) + ' ' +\
1530            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
1531            '>'
1532
1533    def to_dict(self):
1534        return {
1535            'account': self.account,
1536            'meta': self.meta,
1537            'rate_limit': self.rate_limit,
1538        }
1539
1540    @classmethod
1541    def from_dict(cls, d):
1542        return cls(
1543            account=d.get('account'),
1544            meta=d.get('meta'),
1545            rate_limit=d.get('rate_limit'),
1546        )

AccountUpdateResponse returns the fields of a Account after it has been updated by a AccountUpdateRequest.

AccountUpdateResponse(account=None, meta=None, rate_limit=None)
1507    def __init__(
1508        self,
1509        account=None,
1510        meta=None,
1511        rate_limit=None,
1512    ):
1513        self.account = account if account is not None else None
1514        '''
1515         The updated Account.
1516        '''
1517        self.meta = meta if meta is not None else None
1518        '''
1519         Reserved for future use.
1520        '''
1521        self.rate_limit = rate_limit if rate_limit is not None else None
1522        '''
1523         Rate limit information.
1524        '''
account

The updated Account.

meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
1533    def to_dict(self):
1534        return {
1535            'account': self.account,
1536            'meta': self.meta,
1537            'rate_limit': self.rate_limit,
1538        }
@classmethod
def from_dict(cls, d)
1540    @classmethod
1541    def from_dict(cls, d):
1542        return cls(
1543            account=d.get('account'),
1544            meta=d.get('meta'),
1545            rate_limit=d.get('rate_limit'),
1546        )
class AmazonEKS:
1549class AmazonEKS:
1550    '''
1551
1552    '''
1553    __slots__ = [
1554        'access_key',
1555        'bind_interface',
1556        'certificate_authority',
1557        'cluster_name',
1558        'egress_filter',
1559        'endpoint',
1560        'healthcheck_namespace',
1561        'healthy',
1562        'id',
1563        'name',
1564        'region',
1565        'remote_identity_group_id',
1566        'remote_identity_healthcheck_username',
1567        'role_arn',
1568        'role_external_id',
1569        'secret_access_key',
1570        'secret_store_id',
1571        'tags',
1572    ]
1573
1574    def __init__(
1575        self,
1576        access_key=None,
1577        bind_interface=None,
1578        certificate_authority=None,
1579        cluster_name=None,
1580        egress_filter=None,
1581        endpoint=None,
1582        healthcheck_namespace=None,
1583        healthy=None,
1584        id=None,
1585        name=None,
1586        region=None,
1587        remote_identity_group_id=None,
1588        remote_identity_healthcheck_username=None,
1589        role_arn=None,
1590        role_external_id=None,
1591        secret_access_key=None,
1592        secret_store_id=None,
1593        tags=None,
1594    ):
1595        self.access_key = access_key if access_key is not None else ''
1596        '''
1597
1598        '''
1599        self.bind_interface = bind_interface if bind_interface is not None else ''
1600        '''
1601         Bind interface
1602        '''
1603        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
1604        '''
1605
1606        '''
1607        self.cluster_name = cluster_name if cluster_name is not None else ''
1608        '''
1609
1610        '''
1611        self.egress_filter = egress_filter if egress_filter is not None else ''
1612        '''
1613         A filter applied to the routing logic to pin datasource to nodes.
1614        '''
1615        self.endpoint = endpoint if endpoint is not None else ''
1616        '''
1617
1618        '''
1619        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
1620        '''
1621         The path used to check the health of your connection.  Defaults to `default`.
1622        '''
1623        self.healthy = healthy if healthy is not None else False
1624        '''
1625         True if the datasource is reachable and the credentials are valid.
1626        '''
1627        self.id = id if id is not None else ''
1628        '''
1629         Unique identifier of the Resource.
1630        '''
1631        self.name = name if name is not None else ''
1632        '''
1633         Unique human-readable name of the Resource.
1634        '''
1635        self.region = region if region is not None else ''
1636        '''
1637
1638        '''
1639        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
1640        '''
1641
1642        '''
1643        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
1644        '''
1645
1646        '''
1647        self.role_arn = role_arn if role_arn is not None else ''
1648        '''
1649
1650        '''
1651        self.role_external_id = role_external_id if role_external_id is not None else ''
1652        '''
1653
1654        '''
1655        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
1656        '''
1657
1658        '''
1659        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
1660        '''
1661         ID of the secret store containing credentials for this resource, if any.
1662        '''
1663        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
1664        '''
1665         Tags is a map of key, value pairs.
1666        '''
1667
1668    def __repr__(self):
1669        return '<sdm.AmazonEKS ' + \
1670            'access_key: ' + repr(self.access_key) + ' ' +\
1671            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
1672            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
1673            'cluster_name: ' + repr(self.cluster_name) + ' ' +\
1674            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
1675            'endpoint: ' + repr(self.endpoint) + ' ' +\
1676            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
1677            'healthy: ' + repr(self.healthy) + ' ' +\
1678            'id: ' + repr(self.id) + ' ' +\
1679            'name: ' + repr(self.name) + ' ' +\
1680            'region: ' + repr(self.region) + ' ' +\
1681            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
1682            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
1683            'role_arn: ' + repr(self.role_arn) + ' ' +\
1684            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
1685            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
1686            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
1687            'tags: ' + repr(self.tags) + ' ' +\
1688            '>'
1689
1690    def to_dict(self):
1691        return {
1692            'access_key': self.access_key,
1693            'bind_interface': self.bind_interface,
1694            'certificate_authority': self.certificate_authority,
1695            'cluster_name': self.cluster_name,
1696            'egress_filter': self.egress_filter,
1697            'endpoint': self.endpoint,
1698            'healthcheck_namespace': self.healthcheck_namespace,
1699            'healthy': self.healthy,
1700            'id': self.id,
1701            'name': self.name,
1702            'region': self.region,
1703            'remote_identity_group_id': self.remote_identity_group_id,
1704            'remote_identity_healthcheck_username':
1705            self.remote_identity_healthcheck_username,
1706            'role_arn': self.role_arn,
1707            'role_external_id': self.role_external_id,
1708            'secret_access_key': self.secret_access_key,
1709            'secret_store_id': self.secret_store_id,
1710            'tags': self.tags,
1711        }
1712
1713    @classmethod
1714    def from_dict(cls, d):
1715        return cls(
1716            access_key=d.get('access_key'),
1717            bind_interface=d.get('bind_interface'),
1718            certificate_authority=d.get('certificate_authority'),
1719            cluster_name=d.get('cluster_name'),
1720            egress_filter=d.get('egress_filter'),
1721            endpoint=d.get('endpoint'),
1722            healthcheck_namespace=d.get('healthcheck_namespace'),
1723            healthy=d.get('healthy'),
1724            id=d.get('id'),
1725            name=d.get('name'),
1726            region=d.get('region'),
1727            remote_identity_group_id=d.get('remote_identity_group_id'),
1728            remote_identity_healthcheck_username=d.get(
1729                'remote_identity_healthcheck_username'),
1730            role_arn=d.get('role_arn'),
1731            role_external_id=d.get('role_external_id'),
1732            secret_access_key=d.get('secret_access_key'),
1733            secret_store_id=d.get('secret_store_id'),
1734            tags=d.get('tags'),
1735        )
AmazonEKS( access_key=None, bind_interface=None, certificate_authority=None, cluster_name=None, egress_filter=None, endpoint=None, healthcheck_namespace=None, healthy=None, id=None, name=None, region=None, remote_identity_group_id=None, remote_identity_healthcheck_username=None, role_arn=None, role_external_id=None, secret_access_key=None, secret_store_id=None, tags=None)
1574    def __init__(
1575        self,
1576        access_key=None,
1577        bind_interface=None,
1578        certificate_authority=None,
1579        cluster_name=None,
1580        egress_filter=None,
1581        endpoint=None,
1582        healthcheck_namespace=None,
1583        healthy=None,
1584        id=None,
1585        name=None,
1586        region=None,
1587        remote_identity_group_id=None,
1588        remote_identity_healthcheck_username=None,
1589        role_arn=None,
1590        role_external_id=None,
1591        secret_access_key=None,
1592        secret_store_id=None,
1593        tags=None,
1594    ):
1595        self.access_key = access_key if access_key is not None else ''
1596        '''
1597
1598        '''
1599        self.bind_interface = bind_interface if bind_interface is not None else ''
1600        '''
1601         Bind interface
1602        '''
1603        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
1604        '''
1605
1606        '''
1607        self.cluster_name = cluster_name if cluster_name is not None else ''
1608        '''
1609
1610        '''
1611        self.egress_filter = egress_filter if egress_filter is not None else ''
1612        '''
1613         A filter applied to the routing logic to pin datasource to nodes.
1614        '''
1615        self.endpoint = endpoint if endpoint is not None else ''
1616        '''
1617
1618        '''
1619        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
1620        '''
1621         The path used to check the health of your connection.  Defaults to `default`.
1622        '''
1623        self.healthy = healthy if healthy is not None else False
1624        '''
1625         True if the datasource is reachable and the credentials are valid.
1626        '''
1627        self.id = id if id is not None else ''
1628        '''
1629         Unique identifier of the Resource.
1630        '''
1631        self.name = name if name is not None else ''
1632        '''
1633         Unique human-readable name of the Resource.
1634        '''
1635        self.region = region if region is not None else ''
1636        '''
1637
1638        '''
1639        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
1640        '''
1641
1642        '''
1643        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
1644        '''
1645
1646        '''
1647        self.role_arn = role_arn if role_arn is not None else ''
1648        '''
1649
1650        '''
1651        self.role_external_id = role_external_id if role_external_id is not None else ''
1652        '''
1653
1654        '''
1655        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
1656        '''
1657
1658        '''
1659        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
1660        '''
1661         ID of the secret store containing credentials for this resource, if any.
1662        '''
1663        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
1664        '''
1665         Tags is a map of key, value pairs.
1666        '''
access_key
bind_interface

Bind interface

certificate_authority
cluster_name
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

endpoint
healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

region
remote_identity_group_id
remote_identity_healthcheck_username
role_arn
role_external_id
secret_access_key
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
1690    def to_dict(self):
1691        return {
1692            'access_key': self.access_key,
1693            'bind_interface': self.bind_interface,
1694            'certificate_authority': self.certificate_authority,
1695            'cluster_name': self.cluster_name,
1696            'egress_filter': self.egress_filter,
1697            'endpoint': self.endpoint,
1698            'healthcheck_namespace': self.healthcheck_namespace,
1699            'healthy': self.healthy,
1700            'id': self.id,
1701            'name': self.name,
1702            'region': self.region,
1703            'remote_identity_group_id': self.remote_identity_group_id,
1704            'remote_identity_healthcheck_username':
1705            self.remote_identity_healthcheck_username,
1706            'role_arn': self.role_arn,
1707            'role_external_id': self.role_external_id,
1708            'secret_access_key': self.secret_access_key,
1709            'secret_store_id': self.secret_store_id,
1710            'tags': self.tags,
1711        }
@classmethod
def from_dict(cls, d)
1713    @classmethod
1714    def from_dict(cls, d):
1715        return cls(
1716            access_key=d.get('access_key'),
1717            bind_interface=d.get('bind_interface'),
1718            certificate_authority=d.get('certificate_authority'),
1719            cluster_name=d.get('cluster_name'),
1720            egress_filter=d.get('egress_filter'),
1721            endpoint=d.get('endpoint'),
1722            healthcheck_namespace=d.get('healthcheck_namespace'),
1723            healthy=d.get('healthy'),
1724            id=d.get('id'),
1725            name=d.get('name'),
1726            region=d.get('region'),
1727            remote_identity_group_id=d.get('remote_identity_group_id'),
1728            remote_identity_healthcheck_username=d.get(
1729                'remote_identity_healthcheck_username'),
1730            role_arn=d.get('role_arn'),
1731            role_external_id=d.get('role_external_id'),
1732            secret_access_key=d.get('secret_access_key'),
1733            secret_store_id=d.get('secret_store_id'),
1734            tags=d.get('tags'),
1735        )
class AmazonEKSUserImpersonation:
1738class AmazonEKSUserImpersonation:
1739    '''
1740
1741    '''
1742    __slots__ = [
1743        'access_key',
1744        'bind_interface',
1745        'certificate_authority',
1746        'cluster_name',
1747        'egress_filter',
1748        'endpoint',
1749        'healthcheck_namespace',
1750        'healthy',
1751        'id',
1752        'name',
1753        'region',
1754        'role_arn',
1755        'role_external_id',
1756        'secret_access_key',
1757        'secret_store_id',
1758        'tags',
1759    ]
1760
1761    def __init__(
1762        self,
1763        access_key=None,
1764        bind_interface=None,
1765        certificate_authority=None,
1766        cluster_name=None,
1767        egress_filter=None,
1768        endpoint=None,
1769        healthcheck_namespace=None,
1770        healthy=None,
1771        id=None,
1772        name=None,
1773        region=None,
1774        role_arn=None,
1775        role_external_id=None,
1776        secret_access_key=None,
1777        secret_store_id=None,
1778        tags=None,
1779    ):
1780        self.access_key = access_key if access_key is not None else ''
1781        '''
1782
1783        '''
1784        self.bind_interface = bind_interface if bind_interface is not None else ''
1785        '''
1786         Bind interface
1787        '''
1788        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
1789        '''
1790
1791        '''
1792        self.cluster_name = cluster_name if cluster_name is not None else ''
1793        '''
1794
1795        '''
1796        self.egress_filter = egress_filter if egress_filter is not None else ''
1797        '''
1798         A filter applied to the routing logic to pin datasource to nodes.
1799        '''
1800        self.endpoint = endpoint if endpoint is not None else ''
1801        '''
1802
1803        '''
1804        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
1805        '''
1806         The path used to check the health of your connection.  Defaults to `default`.
1807        '''
1808        self.healthy = healthy if healthy is not None else False
1809        '''
1810         True if the datasource is reachable and the credentials are valid.
1811        '''
1812        self.id = id if id is not None else ''
1813        '''
1814         Unique identifier of the Resource.
1815        '''
1816        self.name = name if name is not None else ''
1817        '''
1818         Unique human-readable name of the Resource.
1819        '''
1820        self.region = region if region is not None else ''
1821        '''
1822
1823        '''
1824        self.role_arn = role_arn if role_arn is not None else ''
1825        '''
1826
1827        '''
1828        self.role_external_id = role_external_id if role_external_id is not None else ''
1829        '''
1830
1831        '''
1832        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
1833        '''
1834
1835        '''
1836        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
1837        '''
1838         ID of the secret store containing credentials for this resource, if any.
1839        '''
1840        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
1841        '''
1842         Tags is a map of key, value pairs.
1843        '''
1844
1845    def __repr__(self):
1846        return '<sdm.AmazonEKSUserImpersonation ' + \
1847            'access_key: ' + repr(self.access_key) + ' ' +\
1848            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
1849            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
1850            'cluster_name: ' + repr(self.cluster_name) + ' ' +\
1851            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
1852            'endpoint: ' + repr(self.endpoint) + ' ' +\
1853            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
1854            'healthy: ' + repr(self.healthy) + ' ' +\
1855            'id: ' + repr(self.id) + ' ' +\
1856            'name: ' + repr(self.name) + ' ' +\
1857            'region: ' + repr(self.region) + ' ' +\
1858            'role_arn: ' + repr(self.role_arn) + ' ' +\
1859            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
1860            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
1861            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
1862            'tags: ' + repr(self.tags) + ' ' +\
1863            '>'
1864
1865    def to_dict(self):
1866        return {
1867            'access_key': self.access_key,
1868            'bind_interface': self.bind_interface,
1869            'certificate_authority': self.certificate_authority,
1870            'cluster_name': self.cluster_name,
1871            'egress_filter': self.egress_filter,
1872            'endpoint': self.endpoint,
1873            'healthcheck_namespace': self.healthcheck_namespace,
1874            'healthy': self.healthy,
1875            'id': self.id,
1876            'name': self.name,
1877            'region': self.region,
1878            'role_arn': self.role_arn,
1879            'role_external_id': self.role_external_id,
1880            'secret_access_key': self.secret_access_key,
1881            'secret_store_id': self.secret_store_id,
1882            'tags': self.tags,
1883        }
1884
1885    @classmethod
1886    def from_dict(cls, d):
1887        return cls(
1888            access_key=d.get('access_key'),
1889            bind_interface=d.get('bind_interface'),
1890            certificate_authority=d.get('certificate_authority'),
1891            cluster_name=d.get('cluster_name'),
1892            egress_filter=d.get('egress_filter'),
1893            endpoint=d.get('endpoint'),
1894            healthcheck_namespace=d.get('healthcheck_namespace'),
1895            healthy=d.get('healthy'),
1896            id=d.get('id'),
1897            name=d.get('name'),
1898            region=d.get('region'),
1899            role_arn=d.get('role_arn'),
1900            role_external_id=d.get('role_external_id'),
1901            secret_access_key=d.get('secret_access_key'),
1902            secret_store_id=d.get('secret_store_id'),
1903            tags=d.get('tags'),
1904        )
AmazonEKSUserImpersonation( access_key=None, bind_interface=None, certificate_authority=None, cluster_name=None, egress_filter=None, endpoint=None, healthcheck_namespace=None, healthy=None, id=None, name=None, region=None, role_arn=None, role_external_id=None, secret_access_key=None, secret_store_id=None, tags=None)
1761    def __init__(
1762        self,
1763        access_key=None,
1764        bind_interface=None,
1765        certificate_authority=None,
1766        cluster_name=None,
1767        egress_filter=None,
1768        endpoint=None,
1769        healthcheck_namespace=None,
1770        healthy=None,
1771        id=None,
1772        name=None,
1773        region=None,
1774        role_arn=None,
1775        role_external_id=None,
1776        secret_access_key=None,
1777        secret_store_id=None,
1778        tags=None,
1779    ):
1780        self.access_key = access_key if access_key is not None else ''
1781        '''
1782
1783        '''
1784        self.bind_interface = bind_interface if bind_interface is not None else ''
1785        '''
1786         Bind interface
1787        '''
1788        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
1789        '''
1790
1791        '''
1792        self.cluster_name = cluster_name if cluster_name is not None else ''
1793        '''
1794
1795        '''
1796        self.egress_filter = egress_filter if egress_filter is not None else ''
1797        '''
1798         A filter applied to the routing logic to pin datasource to nodes.
1799        '''
1800        self.endpoint = endpoint if endpoint is not None else ''
1801        '''
1802
1803        '''
1804        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
1805        '''
1806         The path used to check the health of your connection.  Defaults to `default`.
1807        '''
1808        self.healthy = healthy if healthy is not None else False
1809        '''
1810         True if the datasource is reachable and the credentials are valid.
1811        '''
1812        self.id = id if id is not None else ''
1813        '''
1814         Unique identifier of the Resource.
1815        '''
1816        self.name = name if name is not None else ''
1817        '''
1818         Unique human-readable name of the Resource.
1819        '''
1820        self.region = region if region is not None else ''
1821        '''
1822
1823        '''
1824        self.role_arn = role_arn if role_arn is not None else ''
1825        '''
1826
1827        '''
1828        self.role_external_id = role_external_id if role_external_id is not None else ''
1829        '''
1830
1831        '''
1832        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
1833        '''
1834
1835        '''
1836        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
1837        '''
1838         ID of the secret store containing credentials for this resource, if any.
1839        '''
1840        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
1841        '''
1842         Tags is a map of key, value pairs.
1843        '''
access_key
bind_interface

Bind interface

certificate_authority
cluster_name
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

endpoint
healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

region
role_arn
role_external_id
secret_access_key
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
1865    def to_dict(self):
1866        return {
1867            'access_key': self.access_key,
1868            'bind_interface': self.bind_interface,
1869            'certificate_authority': self.certificate_authority,
1870            'cluster_name': self.cluster_name,
1871            'egress_filter': self.egress_filter,
1872            'endpoint': self.endpoint,
1873            'healthcheck_namespace': self.healthcheck_namespace,
1874            'healthy': self.healthy,
1875            'id': self.id,
1876            'name': self.name,
1877            'region': self.region,
1878            'role_arn': self.role_arn,
1879            'role_external_id': self.role_external_id,
1880            'secret_access_key': self.secret_access_key,
1881            'secret_store_id': self.secret_store_id,
1882            'tags': self.tags,
1883        }
@classmethod
def from_dict(cls, d)
1885    @classmethod
1886    def from_dict(cls, d):
1887        return cls(
1888            access_key=d.get('access_key'),
1889            bind_interface=d.get('bind_interface'),
1890            certificate_authority=d.get('certificate_authority'),
1891            cluster_name=d.get('cluster_name'),
1892            egress_filter=d.get('egress_filter'),
1893            endpoint=d.get('endpoint'),
1894            healthcheck_namespace=d.get('healthcheck_namespace'),
1895            healthy=d.get('healthy'),
1896            id=d.get('id'),
1897            name=d.get('name'),
1898            region=d.get('region'),
1899            role_arn=d.get('role_arn'),
1900            role_external_id=d.get('role_external_id'),
1901            secret_access_key=d.get('secret_access_key'),
1902            secret_store_id=d.get('secret_store_id'),
1903            tags=d.get('tags'),
1904        )
class AmazonES:
1907class AmazonES:
1908    '''
1909
1910    '''
1911    __slots__ = [
1912        'access_key',
1913        'bind_interface',
1914        'egress_filter',
1915        'endpoint',
1916        'healthy',
1917        'id',
1918        'name',
1919        'port_override',
1920        'region',
1921        'role_arn',
1922        'role_external_id',
1923        'secret_access_key',
1924        'secret_store_id',
1925        'tags',
1926    ]
1927
1928    def __init__(
1929        self,
1930        access_key=None,
1931        bind_interface=None,
1932        egress_filter=None,
1933        endpoint=None,
1934        healthy=None,
1935        id=None,
1936        name=None,
1937        port_override=None,
1938        region=None,
1939        role_arn=None,
1940        role_external_id=None,
1941        secret_access_key=None,
1942        secret_store_id=None,
1943        tags=None,
1944    ):
1945        self.access_key = access_key if access_key is not None else ''
1946        '''
1947
1948        '''
1949        self.bind_interface = bind_interface if bind_interface is not None else ''
1950        '''
1951         Bind interface
1952        '''
1953        self.egress_filter = egress_filter if egress_filter is not None else ''
1954        '''
1955         A filter applied to the routing logic to pin datasource to nodes.
1956        '''
1957        self.endpoint = endpoint if endpoint is not None else ''
1958        '''
1959
1960        '''
1961        self.healthy = healthy if healthy is not None else False
1962        '''
1963         True if the datasource is reachable and the credentials are valid.
1964        '''
1965        self.id = id if id is not None else ''
1966        '''
1967         Unique identifier of the Resource.
1968        '''
1969        self.name = name if name is not None else ''
1970        '''
1971         Unique human-readable name of the Resource.
1972        '''
1973        self.port_override = port_override if port_override is not None else 0
1974        '''
1975
1976        '''
1977        self.region = region if region is not None else ''
1978        '''
1979
1980        '''
1981        self.role_arn = role_arn if role_arn is not None else ''
1982        '''
1983
1984        '''
1985        self.role_external_id = role_external_id if role_external_id is not None else ''
1986        '''
1987
1988        '''
1989        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
1990        '''
1991
1992        '''
1993        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
1994        '''
1995         ID of the secret store containing credentials for this resource, if any.
1996        '''
1997        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
1998        '''
1999         Tags is a map of key, value pairs.
2000        '''
2001
2002    def __repr__(self):
2003        return '<sdm.AmazonES ' + \
2004            'access_key: ' + repr(self.access_key) + ' ' +\
2005            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
2006            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
2007            'endpoint: ' + repr(self.endpoint) + ' ' +\
2008            'healthy: ' + repr(self.healthy) + ' ' +\
2009            'id: ' + repr(self.id) + ' ' +\
2010            'name: ' + repr(self.name) + ' ' +\
2011            'port_override: ' + repr(self.port_override) + ' ' +\
2012            'region: ' + repr(self.region) + ' ' +\
2013            'role_arn: ' + repr(self.role_arn) + ' ' +\
2014            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
2015            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
2016            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
2017            'tags: ' + repr(self.tags) + ' ' +\
2018            '>'
2019
2020    def to_dict(self):
2021        return {
2022            'access_key': self.access_key,
2023            'bind_interface': self.bind_interface,
2024            'egress_filter': self.egress_filter,
2025            'endpoint': self.endpoint,
2026            'healthy': self.healthy,
2027            'id': self.id,
2028            'name': self.name,
2029            'port_override': self.port_override,
2030            'region': self.region,
2031            'role_arn': self.role_arn,
2032            'role_external_id': self.role_external_id,
2033            'secret_access_key': self.secret_access_key,
2034            'secret_store_id': self.secret_store_id,
2035            'tags': self.tags,
2036        }
2037
2038    @classmethod
2039    def from_dict(cls, d):
2040        return cls(
2041            access_key=d.get('access_key'),
2042            bind_interface=d.get('bind_interface'),
2043            egress_filter=d.get('egress_filter'),
2044            endpoint=d.get('endpoint'),
2045            healthy=d.get('healthy'),
2046            id=d.get('id'),
2047            name=d.get('name'),
2048            port_override=d.get('port_override'),
2049            region=d.get('region'),
2050            role_arn=d.get('role_arn'),
2051            role_external_id=d.get('role_external_id'),
2052            secret_access_key=d.get('secret_access_key'),
2053            secret_store_id=d.get('secret_store_id'),
2054            tags=d.get('tags'),
2055        )
AmazonES( access_key=None, bind_interface=None, egress_filter=None, endpoint=None, healthy=None, id=None, name=None, port_override=None, region=None, role_arn=None, role_external_id=None, secret_access_key=None, secret_store_id=None, tags=None)
1928    def __init__(
1929        self,
1930        access_key=None,
1931        bind_interface=None,
1932        egress_filter=None,
1933        endpoint=None,
1934        healthy=None,
1935        id=None,
1936        name=None,
1937        port_override=None,
1938        region=None,
1939        role_arn=None,
1940        role_external_id=None,
1941        secret_access_key=None,
1942        secret_store_id=None,
1943        tags=None,
1944    ):
1945        self.access_key = access_key if access_key is not None else ''
1946        '''
1947
1948        '''
1949        self.bind_interface = bind_interface if bind_interface is not None else ''
1950        '''
1951         Bind interface
1952        '''
1953        self.egress_filter = egress_filter if egress_filter is not None else ''
1954        '''
1955         A filter applied to the routing logic to pin datasource to nodes.
1956        '''
1957        self.endpoint = endpoint if endpoint is not None else ''
1958        '''
1959
1960        '''
1961        self.healthy = healthy if healthy is not None else False
1962        '''
1963         True if the datasource is reachable and the credentials are valid.
1964        '''
1965        self.id = id if id is not None else ''
1966        '''
1967         Unique identifier of the Resource.
1968        '''
1969        self.name = name if name is not None else ''
1970        '''
1971         Unique human-readable name of the Resource.
1972        '''
1973        self.port_override = port_override if port_override is not None else 0
1974        '''
1975
1976        '''
1977        self.region = region if region is not None else ''
1978        '''
1979
1980        '''
1981        self.role_arn = role_arn if role_arn is not None else ''
1982        '''
1983
1984        '''
1985        self.role_external_id = role_external_id if role_external_id is not None else ''
1986        '''
1987
1988        '''
1989        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
1990        '''
1991
1992        '''
1993        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
1994        '''
1995         ID of the secret store containing credentials for this resource, if any.
1996        '''
1997        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
1998        '''
1999         Tags is a map of key, value pairs.
2000        '''
access_key
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

endpoint
healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port_override
region
role_arn
role_external_id
secret_access_key
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
2020    def to_dict(self):
2021        return {
2022            'access_key': self.access_key,
2023            'bind_interface': self.bind_interface,
2024            'egress_filter': self.egress_filter,
2025            'endpoint': self.endpoint,
2026            'healthy': self.healthy,
2027            'id': self.id,
2028            'name': self.name,
2029            'port_override': self.port_override,
2030            'region': self.region,
2031            'role_arn': self.role_arn,
2032            'role_external_id': self.role_external_id,
2033            'secret_access_key': self.secret_access_key,
2034            'secret_store_id': self.secret_store_id,
2035            'tags': self.tags,
2036        }
@classmethod
def from_dict(cls, d)
2038    @classmethod
2039    def from_dict(cls, d):
2040        return cls(
2041            access_key=d.get('access_key'),
2042            bind_interface=d.get('bind_interface'),
2043            egress_filter=d.get('egress_filter'),
2044            endpoint=d.get('endpoint'),
2045            healthy=d.get('healthy'),
2046            id=d.get('id'),
2047            name=d.get('name'),
2048            port_override=d.get('port_override'),
2049            region=d.get('region'),
2050            role_arn=d.get('role_arn'),
2051            role_external_id=d.get('role_external_id'),
2052            secret_access_key=d.get('secret_access_key'),
2053            secret_store_id=d.get('secret_store_id'),
2054            tags=d.get('tags'),
2055        )
class AmazonMQAMQP091:
2058class AmazonMQAMQP091:
2059    '''
2060
2061    '''
2062    __slots__ = [
2063        'bind_interface',
2064        'egress_filter',
2065        'healthy',
2066        'hostname',
2067        'id',
2068        'name',
2069        'password',
2070        'port',
2071        'port_override',
2072        'secret_store_id',
2073        'tags',
2074        'tls_required',
2075        'username',
2076    ]
2077
2078    def __init__(
2079        self,
2080        bind_interface=None,
2081        egress_filter=None,
2082        healthy=None,
2083        hostname=None,
2084        id=None,
2085        name=None,
2086        password=None,
2087        port=None,
2088        port_override=None,
2089        secret_store_id=None,
2090        tags=None,
2091        tls_required=None,
2092        username=None,
2093    ):
2094        self.bind_interface = bind_interface if bind_interface is not None else ''
2095        '''
2096         Bind interface
2097        '''
2098        self.egress_filter = egress_filter if egress_filter is not None else ''
2099        '''
2100         A filter applied to the routing logic to pin datasource to nodes.
2101        '''
2102        self.healthy = healthy if healthy is not None else False
2103        '''
2104         True if the datasource is reachable and the credentials are valid.
2105        '''
2106        self.hostname = hostname if hostname is not None else ''
2107        '''
2108
2109        '''
2110        self.id = id if id is not None else ''
2111        '''
2112         Unique identifier of the Resource.
2113        '''
2114        self.name = name if name is not None else ''
2115        '''
2116         Unique human-readable name of the Resource.
2117        '''
2118        self.password = password if password is not None else ''
2119        '''
2120
2121        '''
2122        self.port = port if port is not None else 0
2123        '''
2124
2125        '''
2126        self.port_override = port_override if port_override is not None else 0
2127        '''
2128
2129        '''
2130        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2131        '''
2132         ID of the secret store containing credentials for this resource, if any.
2133        '''
2134        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2135        '''
2136         Tags is a map of key, value pairs.
2137        '''
2138        self.tls_required = tls_required if tls_required is not None else False
2139        '''
2140
2141        '''
2142        self.username = username if username is not None else ''
2143        '''
2144
2145        '''
2146
2147    def __repr__(self):
2148        return '<sdm.AmazonMQAMQP091 ' + \
2149            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
2150            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
2151            'healthy: ' + repr(self.healthy) + ' ' +\
2152            'hostname: ' + repr(self.hostname) + ' ' +\
2153            'id: ' + repr(self.id) + ' ' +\
2154            'name: ' + repr(self.name) + ' ' +\
2155            'password: ' + repr(self.password) + ' ' +\
2156            'port: ' + repr(self.port) + ' ' +\
2157            'port_override: ' + repr(self.port_override) + ' ' +\
2158            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
2159            'tags: ' + repr(self.tags) + ' ' +\
2160            'tls_required: ' + repr(self.tls_required) + ' ' +\
2161            'username: ' + repr(self.username) + ' ' +\
2162            '>'
2163
2164    def to_dict(self):
2165        return {
2166            'bind_interface': self.bind_interface,
2167            'egress_filter': self.egress_filter,
2168            'healthy': self.healthy,
2169            'hostname': self.hostname,
2170            'id': self.id,
2171            'name': self.name,
2172            'password': self.password,
2173            'port': self.port,
2174            'port_override': self.port_override,
2175            'secret_store_id': self.secret_store_id,
2176            'tags': self.tags,
2177            'tls_required': self.tls_required,
2178            'username': self.username,
2179        }
2180
2181    @classmethod
2182    def from_dict(cls, d):
2183        return cls(
2184            bind_interface=d.get('bind_interface'),
2185            egress_filter=d.get('egress_filter'),
2186            healthy=d.get('healthy'),
2187            hostname=d.get('hostname'),
2188            id=d.get('id'),
2189            name=d.get('name'),
2190            password=d.get('password'),
2191            port=d.get('port'),
2192            port_override=d.get('port_override'),
2193            secret_store_id=d.get('secret_store_id'),
2194            tags=d.get('tags'),
2195            tls_required=d.get('tls_required'),
2196            username=d.get('username'),
2197        )
AmazonMQAMQP091( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, tls_required=None, username=None)
2078    def __init__(
2079        self,
2080        bind_interface=None,
2081        egress_filter=None,
2082        healthy=None,
2083        hostname=None,
2084        id=None,
2085        name=None,
2086        password=None,
2087        port=None,
2088        port_override=None,
2089        secret_store_id=None,
2090        tags=None,
2091        tls_required=None,
2092        username=None,
2093    ):
2094        self.bind_interface = bind_interface if bind_interface is not None else ''
2095        '''
2096         Bind interface
2097        '''
2098        self.egress_filter = egress_filter if egress_filter is not None else ''
2099        '''
2100         A filter applied to the routing logic to pin datasource to nodes.
2101        '''
2102        self.healthy = healthy if healthy is not None else False
2103        '''
2104         True if the datasource is reachable and the credentials are valid.
2105        '''
2106        self.hostname = hostname if hostname is not None else ''
2107        '''
2108
2109        '''
2110        self.id = id if id is not None else ''
2111        '''
2112         Unique identifier of the Resource.
2113        '''
2114        self.name = name if name is not None else ''
2115        '''
2116         Unique human-readable name of the Resource.
2117        '''
2118        self.password = password if password is not None else ''
2119        '''
2120
2121        '''
2122        self.port = port if port is not None else 0
2123        '''
2124
2125        '''
2126        self.port_override = port_override if port_override is not None else 0
2127        '''
2128
2129        '''
2130        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2131        '''
2132         ID of the secret store containing credentials for this resource, if any.
2133        '''
2134        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2135        '''
2136         Tags is a map of key, value pairs.
2137        '''
2138        self.tls_required = tls_required if tls_required is not None else False
2139        '''
2140
2141        '''
2142        self.username = username if username is not None else ''
2143        '''
2144
2145        '''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
2164    def to_dict(self):
2165        return {
2166            'bind_interface': self.bind_interface,
2167            'egress_filter': self.egress_filter,
2168            'healthy': self.healthy,
2169            'hostname': self.hostname,
2170            'id': self.id,
2171            'name': self.name,
2172            'password': self.password,
2173            'port': self.port,
2174            'port_override': self.port_override,
2175            'secret_store_id': self.secret_store_id,
2176            'tags': self.tags,
2177            'tls_required': self.tls_required,
2178            'username': self.username,
2179        }
@classmethod
def from_dict(cls, d)
2181    @classmethod
2182    def from_dict(cls, d):
2183        return cls(
2184            bind_interface=d.get('bind_interface'),
2185            egress_filter=d.get('egress_filter'),
2186            healthy=d.get('healthy'),
2187            hostname=d.get('hostname'),
2188            id=d.get('id'),
2189            name=d.get('name'),
2190            password=d.get('password'),
2191            port=d.get('port'),
2192            port_override=d.get('port_override'),
2193            secret_store_id=d.get('secret_store_id'),
2194            tags=d.get('tags'),
2195            tls_required=d.get('tls_required'),
2196            username=d.get('username'),
2197        )
class Athena:
2200class Athena:
2201    '''
2202
2203    '''
2204    __slots__ = [
2205        'access_key',
2206        'bind_interface',
2207        'egress_filter',
2208        'healthy',
2209        'id',
2210        'name',
2211        'output',
2212        'port_override',
2213        'region',
2214        'role_arn',
2215        'role_external_id',
2216        'secret_access_key',
2217        'secret_store_id',
2218        'tags',
2219    ]
2220
2221    def __init__(
2222        self,
2223        access_key=None,
2224        bind_interface=None,
2225        egress_filter=None,
2226        healthy=None,
2227        id=None,
2228        name=None,
2229        output=None,
2230        port_override=None,
2231        region=None,
2232        role_arn=None,
2233        role_external_id=None,
2234        secret_access_key=None,
2235        secret_store_id=None,
2236        tags=None,
2237    ):
2238        self.access_key = access_key if access_key is not None else ''
2239        '''
2240
2241        '''
2242        self.bind_interface = bind_interface if bind_interface is not None else ''
2243        '''
2244         Bind interface
2245        '''
2246        self.egress_filter = egress_filter if egress_filter is not None else ''
2247        '''
2248         A filter applied to the routing logic to pin datasource to nodes.
2249        '''
2250        self.healthy = healthy if healthy is not None else False
2251        '''
2252         True if the datasource is reachable and the credentials are valid.
2253        '''
2254        self.id = id if id is not None else ''
2255        '''
2256         Unique identifier of the Resource.
2257        '''
2258        self.name = name if name is not None else ''
2259        '''
2260         Unique human-readable name of the Resource.
2261        '''
2262        self.output = output if output is not None else ''
2263        '''
2264
2265        '''
2266        self.port_override = port_override if port_override is not None else 0
2267        '''
2268
2269        '''
2270        self.region = region if region is not None else ''
2271        '''
2272
2273        '''
2274        self.role_arn = role_arn if role_arn is not None else ''
2275        '''
2276
2277        '''
2278        self.role_external_id = role_external_id if role_external_id is not None else ''
2279        '''
2280
2281        '''
2282        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
2283        '''
2284
2285        '''
2286        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2287        '''
2288         ID of the secret store containing credentials for this resource, if any.
2289        '''
2290        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2291        '''
2292         Tags is a map of key, value pairs.
2293        '''
2294
2295    def __repr__(self):
2296        return '<sdm.Athena ' + \
2297            'access_key: ' + repr(self.access_key) + ' ' +\
2298            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
2299            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
2300            'healthy: ' + repr(self.healthy) + ' ' +\
2301            'id: ' + repr(self.id) + ' ' +\
2302            'name: ' + repr(self.name) + ' ' +\
2303            'output: ' + repr(self.output) + ' ' +\
2304            'port_override: ' + repr(self.port_override) + ' ' +\
2305            'region: ' + repr(self.region) + ' ' +\
2306            'role_arn: ' + repr(self.role_arn) + ' ' +\
2307            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
2308            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
2309            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
2310            'tags: ' + repr(self.tags) + ' ' +\
2311            '>'
2312
2313    def to_dict(self):
2314        return {
2315            'access_key': self.access_key,
2316            'bind_interface': self.bind_interface,
2317            'egress_filter': self.egress_filter,
2318            'healthy': self.healthy,
2319            'id': self.id,
2320            'name': self.name,
2321            'output': self.output,
2322            'port_override': self.port_override,
2323            'region': self.region,
2324            'role_arn': self.role_arn,
2325            'role_external_id': self.role_external_id,
2326            'secret_access_key': self.secret_access_key,
2327            'secret_store_id': self.secret_store_id,
2328            'tags': self.tags,
2329        }
2330
2331    @classmethod
2332    def from_dict(cls, d):
2333        return cls(
2334            access_key=d.get('access_key'),
2335            bind_interface=d.get('bind_interface'),
2336            egress_filter=d.get('egress_filter'),
2337            healthy=d.get('healthy'),
2338            id=d.get('id'),
2339            name=d.get('name'),
2340            output=d.get('output'),
2341            port_override=d.get('port_override'),
2342            region=d.get('region'),
2343            role_arn=d.get('role_arn'),
2344            role_external_id=d.get('role_external_id'),
2345            secret_access_key=d.get('secret_access_key'),
2346            secret_store_id=d.get('secret_store_id'),
2347            tags=d.get('tags'),
2348        )
Athena( access_key=None, bind_interface=None, egress_filter=None, healthy=None, id=None, name=None, output=None, port_override=None, region=None, role_arn=None, role_external_id=None, secret_access_key=None, secret_store_id=None, tags=None)
2221    def __init__(
2222        self,
2223        access_key=None,
2224        bind_interface=None,
2225        egress_filter=None,
2226        healthy=None,
2227        id=None,
2228        name=None,
2229        output=None,
2230        port_override=None,
2231        region=None,
2232        role_arn=None,
2233        role_external_id=None,
2234        secret_access_key=None,
2235        secret_store_id=None,
2236        tags=None,
2237    ):
2238        self.access_key = access_key if access_key is not None else ''
2239        '''
2240
2241        '''
2242        self.bind_interface = bind_interface if bind_interface is not None else ''
2243        '''
2244         Bind interface
2245        '''
2246        self.egress_filter = egress_filter if egress_filter is not None else ''
2247        '''
2248         A filter applied to the routing logic to pin datasource to nodes.
2249        '''
2250        self.healthy = healthy if healthy is not None else False
2251        '''
2252         True if the datasource is reachable and the credentials are valid.
2253        '''
2254        self.id = id if id is not None else ''
2255        '''
2256         Unique identifier of the Resource.
2257        '''
2258        self.name = name if name is not None else ''
2259        '''
2260         Unique human-readable name of the Resource.
2261        '''
2262        self.output = output if output is not None else ''
2263        '''
2264
2265        '''
2266        self.port_override = port_override if port_override is not None else 0
2267        '''
2268
2269        '''
2270        self.region = region if region is not None else ''
2271        '''
2272
2273        '''
2274        self.role_arn = role_arn if role_arn is not None else ''
2275        '''
2276
2277        '''
2278        self.role_external_id = role_external_id if role_external_id is not None else ''
2279        '''
2280
2281        '''
2282        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
2283        '''
2284
2285        '''
2286        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2287        '''
2288         ID of the secret store containing credentials for this resource, if any.
2289        '''
2290        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2291        '''
2292         Tags is a map of key, value pairs.
2293        '''
access_key
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

output
port_override
region
role_arn
role_external_id
secret_access_key
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
2313    def to_dict(self):
2314        return {
2315            'access_key': self.access_key,
2316            'bind_interface': self.bind_interface,
2317            'egress_filter': self.egress_filter,
2318            'healthy': self.healthy,
2319            'id': self.id,
2320            'name': self.name,
2321            'output': self.output,
2322            'port_override': self.port_override,
2323            'region': self.region,
2324            'role_arn': self.role_arn,
2325            'role_external_id': self.role_external_id,
2326            'secret_access_key': self.secret_access_key,
2327            'secret_store_id': self.secret_store_id,
2328            'tags': self.tags,
2329        }
@classmethod
def from_dict(cls, d)
2331    @classmethod
2332    def from_dict(cls, d):
2333        return cls(
2334            access_key=d.get('access_key'),
2335            bind_interface=d.get('bind_interface'),
2336            egress_filter=d.get('egress_filter'),
2337            healthy=d.get('healthy'),
2338            id=d.get('id'),
2339            name=d.get('name'),
2340            output=d.get('output'),
2341            port_override=d.get('port_override'),
2342            region=d.get('region'),
2343            role_arn=d.get('role_arn'),
2344            role_external_id=d.get('role_external_id'),
2345            secret_access_key=d.get('secret_access_key'),
2346            secret_store_id=d.get('secret_store_id'),
2347            tags=d.get('tags'),
2348        )
class AuroraMysql:
2351class AuroraMysql:
2352    '''
2353
2354    '''
2355    __slots__ = [
2356        'bind_interface',
2357        'database',
2358        'egress_filter',
2359        'healthy',
2360        'hostname',
2361        'id',
2362        'name',
2363        'password',
2364        'port',
2365        'port_override',
2366        'secret_store_id',
2367        'tags',
2368        'username',
2369    ]
2370
2371    def __init__(
2372        self,
2373        bind_interface=None,
2374        database=None,
2375        egress_filter=None,
2376        healthy=None,
2377        hostname=None,
2378        id=None,
2379        name=None,
2380        password=None,
2381        port=None,
2382        port_override=None,
2383        secret_store_id=None,
2384        tags=None,
2385        username=None,
2386    ):
2387        self.bind_interface = bind_interface if bind_interface is not None else ''
2388        '''
2389         Bind interface
2390        '''
2391        self.database = database if database is not None else ''
2392        '''
2393
2394        '''
2395        self.egress_filter = egress_filter if egress_filter is not None else ''
2396        '''
2397         A filter applied to the routing logic to pin datasource to nodes.
2398        '''
2399        self.healthy = healthy if healthy is not None else False
2400        '''
2401         True if the datasource is reachable and the credentials are valid.
2402        '''
2403        self.hostname = hostname if hostname is not None else ''
2404        '''
2405
2406        '''
2407        self.id = id if id is not None else ''
2408        '''
2409         Unique identifier of the Resource.
2410        '''
2411        self.name = name if name is not None else ''
2412        '''
2413         Unique human-readable name of the Resource.
2414        '''
2415        self.password = password if password is not None else ''
2416        '''
2417
2418        '''
2419        self.port = port if port is not None else 0
2420        '''
2421
2422        '''
2423        self.port_override = port_override if port_override is not None else 0
2424        '''
2425
2426        '''
2427        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2428        '''
2429         ID of the secret store containing credentials for this resource, if any.
2430        '''
2431        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2432        '''
2433         Tags is a map of key, value pairs.
2434        '''
2435        self.username = username if username is not None else ''
2436        '''
2437
2438        '''
2439
2440    def __repr__(self):
2441        return '<sdm.AuroraMysql ' + \
2442            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
2443            'database: ' + repr(self.database) + ' ' +\
2444            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
2445            'healthy: ' + repr(self.healthy) + ' ' +\
2446            'hostname: ' + repr(self.hostname) + ' ' +\
2447            'id: ' + repr(self.id) + ' ' +\
2448            'name: ' + repr(self.name) + ' ' +\
2449            'password: ' + repr(self.password) + ' ' +\
2450            'port: ' + repr(self.port) + ' ' +\
2451            'port_override: ' + repr(self.port_override) + ' ' +\
2452            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
2453            'tags: ' + repr(self.tags) + ' ' +\
2454            'username: ' + repr(self.username) + ' ' +\
2455            '>'
2456
2457    def to_dict(self):
2458        return {
2459            'bind_interface': self.bind_interface,
2460            'database': self.database,
2461            'egress_filter': self.egress_filter,
2462            'healthy': self.healthy,
2463            'hostname': self.hostname,
2464            'id': self.id,
2465            'name': self.name,
2466            'password': self.password,
2467            'port': self.port,
2468            'port_override': self.port_override,
2469            'secret_store_id': self.secret_store_id,
2470            'tags': self.tags,
2471            'username': self.username,
2472        }
2473
2474    @classmethod
2475    def from_dict(cls, d):
2476        return cls(
2477            bind_interface=d.get('bind_interface'),
2478            database=d.get('database'),
2479            egress_filter=d.get('egress_filter'),
2480            healthy=d.get('healthy'),
2481            hostname=d.get('hostname'),
2482            id=d.get('id'),
2483            name=d.get('name'),
2484            password=d.get('password'),
2485            port=d.get('port'),
2486            port_override=d.get('port_override'),
2487            secret_store_id=d.get('secret_store_id'),
2488            tags=d.get('tags'),
2489            username=d.get('username'),
2490        )
AuroraMysql( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
2371    def __init__(
2372        self,
2373        bind_interface=None,
2374        database=None,
2375        egress_filter=None,
2376        healthy=None,
2377        hostname=None,
2378        id=None,
2379        name=None,
2380        password=None,
2381        port=None,
2382        port_override=None,
2383        secret_store_id=None,
2384        tags=None,
2385        username=None,
2386    ):
2387        self.bind_interface = bind_interface if bind_interface is not None else ''
2388        '''
2389         Bind interface
2390        '''
2391        self.database = database if database is not None else ''
2392        '''
2393
2394        '''
2395        self.egress_filter = egress_filter if egress_filter is not None else ''
2396        '''
2397         A filter applied to the routing logic to pin datasource to nodes.
2398        '''
2399        self.healthy = healthy if healthy is not None else False
2400        '''
2401         True if the datasource is reachable and the credentials are valid.
2402        '''
2403        self.hostname = hostname if hostname is not None else ''
2404        '''
2405
2406        '''
2407        self.id = id if id is not None else ''
2408        '''
2409         Unique identifier of the Resource.
2410        '''
2411        self.name = name if name is not None else ''
2412        '''
2413         Unique human-readable name of the Resource.
2414        '''
2415        self.password = password if password is not None else ''
2416        '''
2417
2418        '''
2419        self.port = port if port is not None else 0
2420        '''
2421
2422        '''
2423        self.port_override = port_override if port_override is not None else 0
2424        '''
2425
2426        '''
2427        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2428        '''
2429         ID of the secret store containing credentials for this resource, if any.
2430        '''
2431        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2432        '''
2433         Tags is a map of key, value pairs.
2434        '''
2435        self.username = username if username is not None else ''
2436        '''
2437
2438        '''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
2457    def to_dict(self):
2458        return {
2459            'bind_interface': self.bind_interface,
2460            'database': self.database,
2461            'egress_filter': self.egress_filter,
2462            'healthy': self.healthy,
2463            'hostname': self.hostname,
2464            'id': self.id,
2465            'name': self.name,
2466            'password': self.password,
2467            'port': self.port,
2468            'port_override': self.port_override,
2469            'secret_store_id': self.secret_store_id,
2470            'tags': self.tags,
2471            'username': self.username,
2472        }
@classmethod
def from_dict(cls, d)
2474    @classmethod
2475    def from_dict(cls, d):
2476        return cls(
2477            bind_interface=d.get('bind_interface'),
2478            database=d.get('database'),
2479            egress_filter=d.get('egress_filter'),
2480            healthy=d.get('healthy'),
2481            hostname=d.get('hostname'),
2482            id=d.get('id'),
2483            name=d.get('name'),
2484            password=d.get('password'),
2485            port=d.get('port'),
2486            port_override=d.get('port_override'),
2487            secret_store_id=d.get('secret_store_id'),
2488            tags=d.get('tags'),
2489            username=d.get('username'),
2490        )
class AuroraPostgres:
2493class AuroraPostgres:
2494    '''
2495
2496    '''
2497    __slots__ = [
2498        'bind_interface',
2499        'database',
2500        'egress_filter',
2501        'healthy',
2502        'hostname',
2503        'id',
2504        'name',
2505        'override_database',
2506        'password',
2507        'port',
2508        'port_override',
2509        'secret_store_id',
2510        'tags',
2511        'username',
2512    ]
2513
2514    def __init__(
2515        self,
2516        bind_interface=None,
2517        database=None,
2518        egress_filter=None,
2519        healthy=None,
2520        hostname=None,
2521        id=None,
2522        name=None,
2523        override_database=None,
2524        password=None,
2525        port=None,
2526        port_override=None,
2527        secret_store_id=None,
2528        tags=None,
2529        username=None,
2530    ):
2531        self.bind_interface = bind_interface if bind_interface is not None else ''
2532        '''
2533         Bind interface
2534        '''
2535        self.database = database if database is not None else ''
2536        '''
2537
2538        '''
2539        self.egress_filter = egress_filter if egress_filter is not None else ''
2540        '''
2541         A filter applied to the routing logic to pin datasource to nodes.
2542        '''
2543        self.healthy = healthy if healthy is not None else False
2544        '''
2545         True if the datasource is reachable and the credentials are valid.
2546        '''
2547        self.hostname = hostname if hostname is not None else ''
2548        '''
2549
2550        '''
2551        self.id = id if id is not None else ''
2552        '''
2553         Unique identifier of the Resource.
2554        '''
2555        self.name = name if name is not None else ''
2556        '''
2557         Unique human-readable name of the Resource.
2558        '''
2559        self.override_database = override_database if override_database is not None else False
2560        '''
2561
2562        '''
2563        self.password = password if password is not None else ''
2564        '''
2565
2566        '''
2567        self.port = port if port is not None else 0
2568        '''
2569
2570        '''
2571        self.port_override = port_override if port_override is not None else 0
2572        '''
2573
2574        '''
2575        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2576        '''
2577         ID of the secret store containing credentials for this resource, if any.
2578        '''
2579        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2580        '''
2581         Tags is a map of key, value pairs.
2582        '''
2583        self.username = username if username is not None else ''
2584        '''
2585
2586        '''
2587
2588    def __repr__(self):
2589        return '<sdm.AuroraPostgres ' + \
2590            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
2591            'database: ' + repr(self.database) + ' ' +\
2592            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
2593            'healthy: ' + repr(self.healthy) + ' ' +\
2594            'hostname: ' + repr(self.hostname) + ' ' +\
2595            'id: ' + repr(self.id) + ' ' +\
2596            'name: ' + repr(self.name) + ' ' +\
2597            'override_database: ' + repr(self.override_database) + ' ' +\
2598            'password: ' + repr(self.password) + ' ' +\
2599            'port: ' + repr(self.port) + ' ' +\
2600            'port_override: ' + repr(self.port_override) + ' ' +\
2601            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
2602            'tags: ' + repr(self.tags) + ' ' +\
2603            'username: ' + repr(self.username) + ' ' +\
2604            '>'
2605
2606    def to_dict(self):
2607        return {
2608            'bind_interface': self.bind_interface,
2609            'database': self.database,
2610            'egress_filter': self.egress_filter,
2611            'healthy': self.healthy,
2612            'hostname': self.hostname,
2613            'id': self.id,
2614            'name': self.name,
2615            'override_database': self.override_database,
2616            'password': self.password,
2617            'port': self.port,
2618            'port_override': self.port_override,
2619            'secret_store_id': self.secret_store_id,
2620            'tags': self.tags,
2621            'username': self.username,
2622        }
2623
2624    @classmethod
2625    def from_dict(cls, d):
2626        return cls(
2627            bind_interface=d.get('bind_interface'),
2628            database=d.get('database'),
2629            egress_filter=d.get('egress_filter'),
2630            healthy=d.get('healthy'),
2631            hostname=d.get('hostname'),
2632            id=d.get('id'),
2633            name=d.get('name'),
2634            override_database=d.get('override_database'),
2635            password=d.get('password'),
2636            port=d.get('port'),
2637            port_override=d.get('port_override'),
2638            secret_store_id=d.get('secret_store_id'),
2639            tags=d.get('tags'),
2640            username=d.get('username'),
2641        )
AuroraPostgres( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, override_database=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
2514    def __init__(
2515        self,
2516        bind_interface=None,
2517        database=None,
2518        egress_filter=None,
2519        healthy=None,
2520        hostname=None,
2521        id=None,
2522        name=None,
2523        override_database=None,
2524        password=None,
2525        port=None,
2526        port_override=None,
2527        secret_store_id=None,
2528        tags=None,
2529        username=None,
2530    ):
2531        self.bind_interface = bind_interface if bind_interface is not None else ''
2532        '''
2533         Bind interface
2534        '''
2535        self.database = database if database is not None else ''
2536        '''
2537
2538        '''
2539        self.egress_filter = egress_filter if egress_filter is not None else ''
2540        '''
2541         A filter applied to the routing logic to pin datasource to nodes.
2542        '''
2543        self.healthy = healthy if healthy is not None else False
2544        '''
2545         True if the datasource is reachable and the credentials are valid.
2546        '''
2547        self.hostname = hostname if hostname is not None else ''
2548        '''
2549
2550        '''
2551        self.id = id if id is not None else ''
2552        '''
2553         Unique identifier of the Resource.
2554        '''
2555        self.name = name if name is not None else ''
2556        '''
2557         Unique human-readable name of the Resource.
2558        '''
2559        self.override_database = override_database if override_database is not None else False
2560        '''
2561
2562        '''
2563        self.password = password if password is not None else ''
2564        '''
2565
2566        '''
2567        self.port = port if port is not None else 0
2568        '''
2569
2570        '''
2571        self.port_override = port_override if port_override is not None else 0
2572        '''
2573
2574        '''
2575        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2576        '''
2577         ID of the secret store containing credentials for this resource, if any.
2578        '''
2579        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2580        '''
2581         Tags is a map of key, value pairs.
2582        '''
2583        self.username = username if username is not None else ''
2584        '''
2585
2586        '''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

override_database
password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
2606    def to_dict(self):
2607        return {
2608            'bind_interface': self.bind_interface,
2609            'database': self.database,
2610            'egress_filter': self.egress_filter,
2611            'healthy': self.healthy,
2612            'hostname': self.hostname,
2613            'id': self.id,
2614            'name': self.name,
2615            'override_database': self.override_database,
2616            'password': self.password,
2617            'port': self.port,
2618            'port_override': self.port_override,
2619            'secret_store_id': self.secret_store_id,
2620            'tags': self.tags,
2621            'username': self.username,
2622        }
@classmethod
def from_dict(cls, d)
2624    @classmethod
2625    def from_dict(cls, d):
2626        return cls(
2627            bind_interface=d.get('bind_interface'),
2628            database=d.get('database'),
2629            egress_filter=d.get('egress_filter'),
2630            healthy=d.get('healthy'),
2631            hostname=d.get('hostname'),
2632            id=d.get('id'),
2633            name=d.get('name'),
2634            override_database=d.get('override_database'),
2635            password=d.get('password'),
2636            port=d.get('port'),
2637            port_override=d.get('port_override'),
2638            secret_store_id=d.get('secret_store_id'),
2639            tags=d.get('tags'),
2640            username=d.get('username'),
2641        )
class Azure:
2644class Azure:
2645    '''
2646
2647    '''
2648    __slots__ = [
2649        'app_id',
2650        'bind_interface',
2651        'egress_filter',
2652        'healthy',
2653        'id',
2654        'name',
2655        'password',
2656        'secret_store_id',
2657        'tags',
2658        'tenant_id',
2659    ]
2660
2661    def __init__(
2662        self,
2663        app_id=None,
2664        bind_interface=None,
2665        egress_filter=None,
2666        healthy=None,
2667        id=None,
2668        name=None,
2669        password=None,
2670        secret_store_id=None,
2671        tags=None,
2672        tenant_id=None,
2673    ):
2674        self.app_id = app_id if app_id is not None else ''
2675        '''
2676
2677        '''
2678        self.bind_interface = bind_interface if bind_interface is not None else ''
2679        '''
2680         Bind interface
2681        '''
2682        self.egress_filter = egress_filter if egress_filter is not None else ''
2683        '''
2684         A filter applied to the routing logic to pin datasource to nodes.
2685        '''
2686        self.healthy = healthy if healthy is not None else False
2687        '''
2688         True if the datasource is reachable and the credentials are valid.
2689        '''
2690        self.id = id if id is not None else ''
2691        '''
2692         Unique identifier of the Resource.
2693        '''
2694        self.name = name if name is not None else ''
2695        '''
2696         Unique human-readable name of the Resource.
2697        '''
2698        self.password = password if password is not None else ''
2699        '''
2700
2701        '''
2702        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2703        '''
2704         ID of the secret store containing credentials for this resource, if any.
2705        '''
2706        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2707        '''
2708         Tags is a map of key, value pairs.
2709        '''
2710        self.tenant_id = tenant_id if tenant_id is not None else ''
2711        '''
2712
2713        '''
2714
2715    def __repr__(self):
2716        return '<sdm.Azure ' + \
2717            'app_id: ' + repr(self.app_id) + ' ' +\
2718            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
2719            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
2720            'healthy: ' + repr(self.healthy) + ' ' +\
2721            'id: ' + repr(self.id) + ' ' +\
2722            'name: ' + repr(self.name) + ' ' +\
2723            'password: ' + repr(self.password) + ' ' +\
2724            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
2725            'tags: ' + repr(self.tags) + ' ' +\
2726            'tenant_id: ' + repr(self.tenant_id) + ' ' +\
2727            '>'
2728
2729    def to_dict(self):
2730        return {
2731            'app_id': self.app_id,
2732            'bind_interface': self.bind_interface,
2733            'egress_filter': self.egress_filter,
2734            'healthy': self.healthy,
2735            'id': self.id,
2736            'name': self.name,
2737            'password': self.password,
2738            'secret_store_id': self.secret_store_id,
2739            'tags': self.tags,
2740            'tenant_id': self.tenant_id,
2741        }
2742
2743    @classmethod
2744    def from_dict(cls, d):
2745        return cls(
2746            app_id=d.get('app_id'),
2747            bind_interface=d.get('bind_interface'),
2748            egress_filter=d.get('egress_filter'),
2749            healthy=d.get('healthy'),
2750            id=d.get('id'),
2751            name=d.get('name'),
2752            password=d.get('password'),
2753            secret_store_id=d.get('secret_store_id'),
2754            tags=d.get('tags'),
2755            tenant_id=d.get('tenant_id'),
2756        )
Azure( app_id=None, bind_interface=None, egress_filter=None, healthy=None, id=None, name=None, password=None, secret_store_id=None, tags=None, tenant_id=None)
2661    def __init__(
2662        self,
2663        app_id=None,
2664        bind_interface=None,
2665        egress_filter=None,
2666        healthy=None,
2667        id=None,
2668        name=None,
2669        password=None,
2670        secret_store_id=None,
2671        tags=None,
2672        tenant_id=None,
2673    ):
2674        self.app_id = app_id if app_id is not None else ''
2675        '''
2676
2677        '''
2678        self.bind_interface = bind_interface if bind_interface is not None else ''
2679        '''
2680         Bind interface
2681        '''
2682        self.egress_filter = egress_filter if egress_filter is not None else ''
2683        '''
2684         A filter applied to the routing logic to pin datasource to nodes.
2685        '''
2686        self.healthy = healthy if healthy is not None else False
2687        '''
2688         True if the datasource is reachable and the credentials are valid.
2689        '''
2690        self.id = id if id is not None else ''
2691        '''
2692         Unique identifier of the Resource.
2693        '''
2694        self.name = name if name is not None else ''
2695        '''
2696         Unique human-readable name of the Resource.
2697        '''
2698        self.password = password if password is not None else ''
2699        '''
2700
2701        '''
2702        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2703        '''
2704         ID of the secret store containing credentials for this resource, if any.
2705        '''
2706        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2707        '''
2708         Tags is a map of key, value pairs.
2709        '''
2710        self.tenant_id = tenant_id if tenant_id is not None else ''
2711        '''
2712
2713        '''
app_id
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tenant_id
def to_dict(self)
2729    def to_dict(self):
2730        return {
2731            'app_id': self.app_id,
2732            'bind_interface': self.bind_interface,
2733            'egress_filter': self.egress_filter,
2734            'healthy': self.healthy,
2735            'id': self.id,
2736            'name': self.name,
2737            'password': self.password,
2738            'secret_store_id': self.secret_store_id,
2739            'tags': self.tags,
2740            'tenant_id': self.tenant_id,
2741        }
@classmethod
def from_dict(cls, d)
2743    @classmethod
2744    def from_dict(cls, d):
2745        return cls(
2746            app_id=d.get('app_id'),
2747            bind_interface=d.get('bind_interface'),
2748            egress_filter=d.get('egress_filter'),
2749            healthy=d.get('healthy'),
2750            id=d.get('id'),
2751            name=d.get('name'),
2752            password=d.get('password'),
2753            secret_store_id=d.get('secret_store_id'),
2754            tags=d.get('tags'),
2755            tenant_id=d.get('tenant_id'),
2756        )
class AzureCertificate:
2759class AzureCertificate:
2760    '''
2761
2762    '''
2763    __slots__ = [
2764        'app_id',
2765        'bind_interface',
2766        'client_certificate',
2767        'egress_filter',
2768        'healthy',
2769        'id',
2770        'name',
2771        'secret_store_id',
2772        'tags',
2773        'tenant_id',
2774    ]
2775
2776    def __init__(
2777        self,
2778        app_id=None,
2779        bind_interface=None,
2780        client_certificate=None,
2781        egress_filter=None,
2782        healthy=None,
2783        id=None,
2784        name=None,
2785        secret_store_id=None,
2786        tags=None,
2787        tenant_id=None,
2788    ):
2789        self.app_id = app_id if app_id is not None else ''
2790        '''
2791
2792        '''
2793        self.bind_interface = bind_interface if bind_interface is not None else ''
2794        '''
2795         Bind interface
2796        '''
2797        self.client_certificate = client_certificate if client_certificate is not None else ''
2798        '''
2799
2800        '''
2801        self.egress_filter = egress_filter if egress_filter is not None else ''
2802        '''
2803         A filter applied to the routing logic to pin datasource to nodes.
2804        '''
2805        self.healthy = healthy if healthy is not None else False
2806        '''
2807         True if the datasource is reachable and the credentials are valid.
2808        '''
2809        self.id = id if id is not None else ''
2810        '''
2811         Unique identifier of the Resource.
2812        '''
2813        self.name = name if name is not None else ''
2814        '''
2815         Unique human-readable name of the Resource.
2816        '''
2817        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2818        '''
2819         ID of the secret store containing credentials for this resource, if any.
2820        '''
2821        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2822        '''
2823         Tags is a map of key, value pairs.
2824        '''
2825        self.tenant_id = tenant_id if tenant_id is not None else ''
2826        '''
2827
2828        '''
2829
2830    def __repr__(self):
2831        return '<sdm.AzureCertificate ' + \
2832            'app_id: ' + repr(self.app_id) + ' ' +\
2833            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
2834            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
2835            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
2836            'healthy: ' + repr(self.healthy) + ' ' +\
2837            'id: ' + repr(self.id) + ' ' +\
2838            'name: ' + repr(self.name) + ' ' +\
2839            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
2840            'tags: ' + repr(self.tags) + ' ' +\
2841            'tenant_id: ' + repr(self.tenant_id) + ' ' +\
2842            '>'
2843
2844    def to_dict(self):
2845        return {
2846            'app_id': self.app_id,
2847            'bind_interface': self.bind_interface,
2848            'client_certificate': self.client_certificate,
2849            'egress_filter': self.egress_filter,
2850            'healthy': self.healthy,
2851            'id': self.id,
2852            'name': self.name,
2853            'secret_store_id': self.secret_store_id,
2854            'tags': self.tags,
2855            'tenant_id': self.tenant_id,
2856        }
2857
2858    @classmethod
2859    def from_dict(cls, d):
2860        return cls(
2861            app_id=d.get('app_id'),
2862            bind_interface=d.get('bind_interface'),
2863            client_certificate=d.get('client_certificate'),
2864            egress_filter=d.get('egress_filter'),
2865            healthy=d.get('healthy'),
2866            id=d.get('id'),
2867            name=d.get('name'),
2868            secret_store_id=d.get('secret_store_id'),
2869            tags=d.get('tags'),
2870            tenant_id=d.get('tenant_id'),
2871        )
AzureCertificate( app_id=None, bind_interface=None, client_certificate=None, egress_filter=None, healthy=None, id=None, name=None, secret_store_id=None, tags=None, tenant_id=None)
2776    def __init__(
2777        self,
2778        app_id=None,
2779        bind_interface=None,
2780        client_certificate=None,
2781        egress_filter=None,
2782        healthy=None,
2783        id=None,
2784        name=None,
2785        secret_store_id=None,
2786        tags=None,
2787        tenant_id=None,
2788    ):
2789        self.app_id = app_id if app_id is not None else ''
2790        '''
2791
2792        '''
2793        self.bind_interface = bind_interface if bind_interface is not None else ''
2794        '''
2795         Bind interface
2796        '''
2797        self.client_certificate = client_certificate if client_certificate is not None else ''
2798        '''
2799
2800        '''
2801        self.egress_filter = egress_filter if egress_filter is not None else ''
2802        '''
2803         A filter applied to the routing logic to pin datasource to nodes.
2804        '''
2805        self.healthy = healthy if healthy is not None else False
2806        '''
2807         True if the datasource is reachable and the credentials are valid.
2808        '''
2809        self.id = id if id is not None else ''
2810        '''
2811         Unique identifier of the Resource.
2812        '''
2813        self.name = name if name is not None else ''
2814        '''
2815         Unique human-readable name of the Resource.
2816        '''
2817        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2818        '''
2819         ID of the secret store containing credentials for this resource, if any.
2820        '''
2821        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2822        '''
2823         Tags is a map of key, value pairs.
2824        '''
2825        self.tenant_id = tenant_id if tenant_id is not None else ''
2826        '''
2827
2828        '''
app_id
bind_interface

Bind interface

client_certificate
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tenant_id
def to_dict(self)
2844    def to_dict(self):
2845        return {
2846            'app_id': self.app_id,
2847            'bind_interface': self.bind_interface,
2848            'client_certificate': self.client_certificate,
2849            'egress_filter': self.egress_filter,
2850            'healthy': self.healthy,
2851            'id': self.id,
2852            'name': self.name,
2853            'secret_store_id': self.secret_store_id,
2854            'tags': self.tags,
2855            'tenant_id': self.tenant_id,
2856        }
@classmethod
def from_dict(cls, d)
2858    @classmethod
2859    def from_dict(cls, d):
2860        return cls(
2861            app_id=d.get('app_id'),
2862            bind_interface=d.get('bind_interface'),
2863            client_certificate=d.get('client_certificate'),
2864            egress_filter=d.get('egress_filter'),
2865            healthy=d.get('healthy'),
2866            id=d.get('id'),
2867            name=d.get('name'),
2868            secret_store_id=d.get('secret_store_id'),
2869            tags=d.get('tags'),
2870            tenant_id=d.get('tenant_id'),
2871        )
class AzurePostgres:
2874class AzurePostgres:
2875    '''
2876
2877    '''
2878    __slots__ = [
2879        'bind_interface',
2880        'database',
2881        'egress_filter',
2882        'healthy',
2883        'hostname',
2884        'id',
2885        'name',
2886        'override_database',
2887        'password',
2888        'port',
2889        'port_override',
2890        'secret_store_id',
2891        'tags',
2892        'username',
2893    ]
2894
2895    def __init__(
2896        self,
2897        bind_interface=None,
2898        database=None,
2899        egress_filter=None,
2900        healthy=None,
2901        hostname=None,
2902        id=None,
2903        name=None,
2904        override_database=None,
2905        password=None,
2906        port=None,
2907        port_override=None,
2908        secret_store_id=None,
2909        tags=None,
2910        username=None,
2911    ):
2912        self.bind_interface = bind_interface if bind_interface is not None else ''
2913        '''
2914         Bind interface
2915        '''
2916        self.database = database if database is not None else ''
2917        '''
2918
2919        '''
2920        self.egress_filter = egress_filter if egress_filter is not None else ''
2921        '''
2922         A filter applied to the routing logic to pin datasource to nodes.
2923        '''
2924        self.healthy = healthy if healthy is not None else False
2925        '''
2926         True if the datasource is reachable and the credentials are valid.
2927        '''
2928        self.hostname = hostname if hostname is not None else ''
2929        '''
2930
2931        '''
2932        self.id = id if id is not None else ''
2933        '''
2934         Unique identifier of the Resource.
2935        '''
2936        self.name = name if name is not None else ''
2937        '''
2938         Unique human-readable name of the Resource.
2939        '''
2940        self.override_database = override_database if override_database is not None else False
2941        '''
2942
2943        '''
2944        self.password = password if password is not None else ''
2945        '''
2946
2947        '''
2948        self.port = port if port is not None else 0
2949        '''
2950
2951        '''
2952        self.port_override = port_override if port_override is not None else 0
2953        '''
2954
2955        '''
2956        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2957        '''
2958         ID of the secret store containing credentials for this resource, if any.
2959        '''
2960        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2961        '''
2962         Tags is a map of key, value pairs.
2963        '''
2964        self.username = username if username is not None else ''
2965        '''
2966
2967        '''
2968
2969    def __repr__(self):
2970        return '<sdm.AzurePostgres ' + \
2971            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
2972            'database: ' + repr(self.database) + ' ' +\
2973            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
2974            'healthy: ' + repr(self.healthy) + ' ' +\
2975            'hostname: ' + repr(self.hostname) + ' ' +\
2976            'id: ' + repr(self.id) + ' ' +\
2977            'name: ' + repr(self.name) + ' ' +\
2978            'override_database: ' + repr(self.override_database) + ' ' +\
2979            'password: ' + repr(self.password) + ' ' +\
2980            'port: ' + repr(self.port) + ' ' +\
2981            'port_override: ' + repr(self.port_override) + ' ' +\
2982            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
2983            'tags: ' + repr(self.tags) + ' ' +\
2984            'username: ' + repr(self.username) + ' ' +\
2985            '>'
2986
2987    def to_dict(self):
2988        return {
2989            'bind_interface': self.bind_interface,
2990            'database': self.database,
2991            'egress_filter': self.egress_filter,
2992            'healthy': self.healthy,
2993            'hostname': self.hostname,
2994            'id': self.id,
2995            'name': self.name,
2996            'override_database': self.override_database,
2997            'password': self.password,
2998            'port': self.port,
2999            'port_override': self.port_override,
3000            'secret_store_id': self.secret_store_id,
3001            'tags': self.tags,
3002            'username': self.username,
3003        }
3004
3005    @classmethod
3006    def from_dict(cls, d):
3007        return cls(
3008            bind_interface=d.get('bind_interface'),
3009            database=d.get('database'),
3010            egress_filter=d.get('egress_filter'),
3011            healthy=d.get('healthy'),
3012            hostname=d.get('hostname'),
3013            id=d.get('id'),
3014            name=d.get('name'),
3015            override_database=d.get('override_database'),
3016            password=d.get('password'),
3017            port=d.get('port'),
3018            port_override=d.get('port_override'),
3019            secret_store_id=d.get('secret_store_id'),
3020            tags=d.get('tags'),
3021            username=d.get('username'),
3022        )
AzurePostgres( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, override_database=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
2895    def __init__(
2896        self,
2897        bind_interface=None,
2898        database=None,
2899        egress_filter=None,
2900        healthy=None,
2901        hostname=None,
2902        id=None,
2903        name=None,
2904        override_database=None,
2905        password=None,
2906        port=None,
2907        port_override=None,
2908        secret_store_id=None,
2909        tags=None,
2910        username=None,
2911    ):
2912        self.bind_interface = bind_interface if bind_interface is not None else ''
2913        '''
2914         Bind interface
2915        '''
2916        self.database = database if database is not None else ''
2917        '''
2918
2919        '''
2920        self.egress_filter = egress_filter if egress_filter is not None else ''
2921        '''
2922         A filter applied to the routing logic to pin datasource to nodes.
2923        '''
2924        self.healthy = healthy if healthy is not None else False
2925        '''
2926         True if the datasource is reachable and the credentials are valid.
2927        '''
2928        self.hostname = hostname if hostname is not None else ''
2929        '''
2930
2931        '''
2932        self.id = id if id is not None else ''
2933        '''
2934         Unique identifier of the Resource.
2935        '''
2936        self.name = name if name is not None else ''
2937        '''
2938         Unique human-readable name of the Resource.
2939        '''
2940        self.override_database = override_database if override_database is not None else False
2941        '''
2942
2943        '''
2944        self.password = password if password is not None else ''
2945        '''
2946
2947        '''
2948        self.port = port if port is not None else 0
2949        '''
2950
2951        '''
2952        self.port_override = port_override if port_override is not None else 0
2953        '''
2954
2955        '''
2956        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
2957        '''
2958         ID of the secret store containing credentials for this resource, if any.
2959        '''
2960        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
2961        '''
2962         Tags is a map of key, value pairs.
2963        '''
2964        self.username = username if username is not None else ''
2965        '''
2966
2967        '''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

override_database
password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
2987    def to_dict(self):
2988        return {
2989            'bind_interface': self.bind_interface,
2990            'database': self.database,
2991            'egress_filter': self.egress_filter,
2992            'healthy': self.healthy,
2993            'hostname': self.hostname,
2994            'id': self.id,
2995            'name': self.name,
2996            'override_database': self.override_database,
2997            'password': self.password,
2998            'port': self.port,
2999            'port_override': self.port_override,
3000            'secret_store_id': self.secret_store_id,
3001            'tags': self.tags,
3002            'username': self.username,
3003        }
@classmethod
def from_dict(cls, d)
3005    @classmethod
3006    def from_dict(cls, d):
3007        return cls(
3008            bind_interface=d.get('bind_interface'),
3009            database=d.get('database'),
3010            egress_filter=d.get('egress_filter'),
3011            healthy=d.get('healthy'),
3012            hostname=d.get('hostname'),
3013            id=d.get('id'),
3014            name=d.get('name'),
3015            override_database=d.get('override_database'),
3016            password=d.get('password'),
3017            port=d.get('port'),
3018            port_override=d.get('port_override'),
3019            secret_store_id=d.get('secret_store_id'),
3020            tags=d.get('tags'),
3021            username=d.get('username'),
3022        )
class AzureStore:
3025class AzureStore:
3026    '''
3027
3028    '''
3029    __slots__ = [
3030        'id',
3031        'name',
3032        'tags',
3033        'vault_uri',
3034    ]
3035
3036    def __init__(
3037        self,
3038        id=None,
3039        name=None,
3040        tags=None,
3041        vault_uri=None,
3042    ):
3043        self.id = id if id is not None else ''
3044        '''
3045         Unique identifier of the SecretStore.
3046        '''
3047        self.name = name if name is not None else ''
3048        '''
3049         Unique human-readable name of the SecretStore.
3050        '''
3051        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3052        '''
3053         Tags is a map of key, value pairs.
3054        '''
3055        self.vault_uri = vault_uri if vault_uri is not None else ''
3056        '''
3057
3058        '''
3059
3060    def __repr__(self):
3061        return '<sdm.AzureStore ' + \
3062            'id: ' + repr(self.id) + ' ' +\
3063            'name: ' + repr(self.name) + ' ' +\
3064            'tags: ' + repr(self.tags) + ' ' +\
3065            'vault_uri: ' + repr(self.vault_uri) + ' ' +\
3066            '>'
3067
3068    def to_dict(self):
3069        return {
3070            'id': self.id,
3071            'name': self.name,
3072            'tags': self.tags,
3073            'vault_uri': self.vault_uri,
3074        }
3075
3076    @classmethod
3077    def from_dict(cls, d):
3078        return cls(
3079            id=d.get('id'),
3080            name=d.get('name'),
3081            tags=d.get('tags'),
3082            vault_uri=d.get('vault_uri'),
3083        )
AzureStore(id=None, name=None, tags=None, vault_uri=None)
3036    def __init__(
3037        self,
3038        id=None,
3039        name=None,
3040        tags=None,
3041        vault_uri=None,
3042    ):
3043        self.id = id if id is not None else ''
3044        '''
3045         Unique identifier of the SecretStore.
3046        '''
3047        self.name = name if name is not None else ''
3048        '''
3049         Unique human-readable name of the SecretStore.
3050        '''
3051        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3052        '''
3053         Tags is a map of key, value pairs.
3054        '''
3055        self.vault_uri = vault_uri if vault_uri is not None else ''
3056        '''
3057
3058        '''
id

Unique identifier of the SecretStore.

name

Unique human-readable name of the SecretStore.

tags

Tags is a map of key, value pairs.

vault_uri
def to_dict(self)
3068    def to_dict(self):
3069        return {
3070            'id': self.id,
3071            'name': self.name,
3072            'tags': self.tags,
3073            'vault_uri': self.vault_uri,
3074        }
@classmethod
def from_dict(cls, d)
3076    @classmethod
3077    def from_dict(cls, d):
3078        return cls(
3079            id=d.get('id'),
3080            name=d.get('name'),
3081            tags=d.get('tags'),
3082            vault_uri=d.get('vault_uri'),
3083        )
class BigQuery:
3086class BigQuery:
3087    '''
3088
3089    '''
3090    __slots__ = [
3091        'bind_interface',
3092        'egress_filter',
3093        'endpoint',
3094        'healthy',
3095        'id',
3096        'name',
3097        'port_override',
3098        'private_key',
3099        'project',
3100        'secret_store_id',
3101        'tags',
3102        'username',
3103    ]
3104
3105    def __init__(
3106        self,
3107        bind_interface=None,
3108        egress_filter=None,
3109        endpoint=None,
3110        healthy=None,
3111        id=None,
3112        name=None,
3113        port_override=None,
3114        private_key=None,
3115        project=None,
3116        secret_store_id=None,
3117        tags=None,
3118        username=None,
3119    ):
3120        self.bind_interface = bind_interface if bind_interface is not None else ''
3121        '''
3122         Bind interface
3123        '''
3124        self.egress_filter = egress_filter if egress_filter is not None else ''
3125        '''
3126         A filter applied to the routing logic to pin datasource to nodes.
3127        '''
3128        self.endpoint = endpoint if endpoint is not None else ''
3129        '''
3130
3131        '''
3132        self.healthy = healthy if healthy is not None else False
3133        '''
3134         True if the datasource is reachable and the credentials are valid.
3135        '''
3136        self.id = id if id is not None else ''
3137        '''
3138         Unique identifier of the Resource.
3139        '''
3140        self.name = name if name is not None else ''
3141        '''
3142         Unique human-readable name of the Resource.
3143        '''
3144        self.port_override = port_override if port_override is not None else 0
3145        '''
3146
3147        '''
3148        self.private_key = private_key if private_key is not None else ''
3149        '''
3150
3151        '''
3152        self.project = project if project is not None else ''
3153        '''
3154
3155        '''
3156        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3157        '''
3158         ID of the secret store containing credentials for this resource, if any.
3159        '''
3160        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3161        '''
3162         Tags is a map of key, value pairs.
3163        '''
3164        self.username = username if username is not None else ''
3165        '''
3166
3167        '''
3168
3169    def __repr__(self):
3170        return '<sdm.BigQuery ' + \
3171            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
3172            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
3173            'endpoint: ' + repr(self.endpoint) + ' ' +\
3174            'healthy: ' + repr(self.healthy) + ' ' +\
3175            'id: ' + repr(self.id) + ' ' +\
3176            'name: ' + repr(self.name) + ' ' +\
3177            'port_override: ' + repr(self.port_override) + ' ' +\
3178            'private_key: ' + repr(self.private_key) + ' ' +\
3179            'project: ' + repr(self.project) + ' ' +\
3180            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
3181            'tags: ' + repr(self.tags) + ' ' +\
3182            'username: ' + repr(self.username) + ' ' +\
3183            '>'
3184
3185    def to_dict(self):
3186        return {
3187            'bind_interface': self.bind_interface,
3188            'egress_filter': self.egress_filter,
3189            'endpoint': self.endpoint,
3190            'healthy': self.healthy,
3191            'id': self.id,
3192            'name': self.name,
3193            'port_override': self.port_override,
3194            'private_key': self.private_key,
3195            'project': self.project,
3196            'secret_store_id': self.secret_store_id,
3197            'tags': self.tags,
3198            'username': self.username,
3199        }
3200
3201    @classmethod
3202    def from_dict(cls, d):
3203        return cls(
3204            bind_interface=d.get('bind_interface'),
3205            egress_filter=d.get('egress_filter'),
3206            endpoint=d.get('endpoint'),
3207            healthy=d.get('healthy'),
3208            id=d.get('id'),
3209            name=d.get('name'),
3210            port_override=d.get('port_override'),
3211            private_key=d.get('private_key'),
3212            project=d.get('project'),
3213            secret_store_id=d.get('secret_store_id'),
3214            tags=d.get('tags'),
3215            username=d.get('username'),
3216        )
BigQuery( bind_interface=None, egress_filter=None, endpoint=None, healthy=None, id=None, name=None, port_override=None, private_key=None, project=None, secret_store_id=None, tags=None, username=None)
3105    def __init__(
3106        self,
3107        bind_interface=None,
3108        egress_filter=None,
3109        endpoint=None,
3110        healthy=None,
3111        id=None,
3112        name=None,
3113        port_override=None,
3114        private_key=None,
3115        project=None,
3116        secret_store_id=None,
3117        tags=None,
3118        username=None,
3119    ):
3120        self.bind_interface = bind_interface if bind_interface is not None else ''
3121        '''
3122         Bind interface
3123        '''
3124        self.egress_filter = egress_filter if egress_filter is not None else ''
3125        '''
3126         A filter applied to the routing logic to pin datasource to nodes.
3127        '''
3128        self.endpoint = endpoint if endpoint is not None else ''
3129        '''
3130
3131        '''
3132        self.healthy = healthy if healthy is not None else False
3133        '''
3134         True if the datasource is reachable and the credentials are valid.
3135        '''
3136        self.id = id if id is not None else ''
3137        '''
3138         Unique identifier of the Resource.
3139        '''
3140        self.name = name if name is not None else ''
3141        '''
3142         Unique human-readable name of the Resource.
3143        '''
3144        self.port_override = port_override if port_override is not None else 0
3145        '''
3146
3147        '''
3148        self.private_key = private_key if private_key is not None else ''
3149        '''
3150
3151        '''
3152        self.project = project if project is not None else ''
3153        '''
3154
3155        '''
3156        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3157        '''
3158         ID of the secret store containing credentials for this resource, if any.
3159        '''
3160        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3161        '''
3162         Tags is a map of key, value pairs.
3163        '''
3164        self.username = username if username is not None else ''
3165        '''
3166
3167        '''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

endpoint
healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port_override
private_key
project
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
3185    def to_dict(self):
3186        return {
3187            'bind_interface': self.bind_interface,
3188            'egress_filter': self.egress_filter,
3189            'endpoint': self.endpoint,
3190            'healthy': self.healthy,
3191            'id': self.id,
3192            'name': self.name,
3193            'port_override': self.port_override,
3194            'private_key': self.private_key,
3195            'project': self.project,
3196            'secret_store_id': self.secret_store_id,
3197            'tags': self.tags,
3198            'username': self.username,
3199        }
@classmethod
def from_dict(cls, d)
3201    @classmethod
3202    def from_dict(cls, d):
3203        return cls(
3204            bind_interface=d.get('bind_interface'),
3205            egress_filter=d.get('egress_filter'),
3206            endpoint=d.get('endpoint'),
3207            healthy=d.get('healthy'),
3208            id=d.get('id'),
3209            name=d.get('name'),
3210            port_override=d.get('port_override'),
3211            private_key=d.get('private_key'),
3212            project=d.get('project'),
3213            secret_store_id=d.get('secret_store_id'),
3214            tags=d.get('tags'),
3215            username=d.get('username'),
3216        )
class Cassandra:
3219class Cassandra:
3220    '''
3221
3222    '''
3223    __slots__ = [
3224        'bind_interface',
3225        'egress_filter',
3226        'healthy',
3227        'hostname',
3228        'id',
3229        'name',
3230        'password',
3231        'port',
3232        'port_override',
3233        'secret_store_id',
3234        'tags',
3235        'tls_required',
3236        'username',
3237    ]
3238
3239    def __init__(
3240        self,
3241        bind_interface=None,
3242        egress_filter=None,
3243        healthy=None,
3244        hostname=None,
3245        id=None,
3246        name=None,
3247        password=None,
3248        port=None,
3249        port_override=None,
3250        secret_store_id=None,
3251        tags=None,
3252        tls_required=None,
3253        username=None,
3254    ):
3255        self.bind_interface = bind_interface if bind_interface is not None else ''
3256        '''
3257         Bind interface
3258        '''
3259        self.egress_filter = egress_filter if egress_filter is not None else ''
3260        '''
3261         A filter applied to the routing logic to pin datasource to nodes.
3262        '''
3263        self.healthy = healthy if healthy is not None else False
3264        '''
3265         True if the datasource is reachable and the credentials are valid.
3266        '''
3267        self.hostname = hostname if hostname is not None else ''
3268        '''
3269
3270        '''
3271        self.id = id if id is not None else ''
3272        '''
3273         Unique identifier of the Resource.
3274        '''
3275        self.name = name if name is not None else ''
3276        '''
3277         Unique human-readable name of the Resource.
3278        '''
3279        self.password = password if password is not None else ''
3280        '''
3281
3282        '''
3283        self.port = port if port is not None else 0
3284        '''
3285
3286        '''
3287        self.port_override = port_override if port_override is not None else 0
3288        '''
3289
3290        '''
3291        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3292        '''
3293         ID of the secret store containing credentials for this resource, if any.
3294        '''
3295        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3296        '''
3297         Tags is a map of key, value pairs.
3298        '''
3299        self.tls_required = tls_required if tls_required is not None else False
3300        '''
3301
3302        '''
3303        self.username = username if username is not None else ''
3304        '''
3305
3306        '''
3307
3308    def __repr__(self):
3309        return '<sdm.Cassandra ' + \
3310            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
3311            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
3312            'healthy: ' + repr(self.healthy) + ' ' +\
3313            'hostname: ' + repr(self.hostname) + ' ' +\
3314            'id: ' + repr(self.id) + ' ' +\
3315            'name: ' + repr(self.name) + ' ' +\
3316            'password: ' + repr(self.password) + ' ' +\
3317            'port: ' + repr(self.port) + ' ' +\
3318            'port_override: ' + repr(self.port_override) + ' ' +\
3319            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
3320            'tags: ' + repr(self.tags) + ' ' +\
3321            'tls_required: ' + repr(self.tls_required) + ' ' +\
3322            'username: ' + repr(self.username) + ' ' +\
3323            '>'
3324
3325    def to_dict(self):
3326        return {
3327            'bind_interface': self.bind_interface,
3328            'egress_filter': self.egress_filter,
3329            'healthy': self.healthy,
3330            'hostname': self.hostname,
3331            'id': self.id,
3332            'name': self.name,
3333            'password': self.password,
3334            'port': self.port,
3335            'port_override': self.port_override,
3336            'secret_store_id': self.secret_store_id,
3337            'tags': self.tags,
3338            'tls_required': self.tls_required,
3339            'username': self.username,
3340        }
3341
3342    @classmethod
3343    def from_dict(cls, d):
3344        return cls(
3345            bind_interface=d.get('bind_interface'),
3346            egress_filter=d.get('egress_filter'),
3347            healthy=d.get('healthy'),
3348            hostname=d.get('hostname'),
3349            id=d.get('id'),
3350            name=d.get('name'),
3351            password=d.get('password'),
3352            port=d.get('port'),
3353            port_override=d.get('port_override'),
3354            secret_store_id=d.get('secret_store_id'),
3355            tags=d.get('tags'),
3356            tls_required=d.get('tls_required'),
3357            username=d.get('username'),
3358        )
Cassandra( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, tls_required=None, username=None)
3239    def __init__(
3240        self,
3241        bind_interface=None,
3242        egress_filter=None,
3243        healthy=None,
3244        hostname=None,
3245        id=None,
3246        name=None,
3247        password=None,
3248        port=None,
3249        port_override=None,
3250        secret_store_id=None,
3251        tags=None,
3252        tls_required=None,
3253        username=None,
3254    ):
3255        self.bind_interface = bind_interface if bind_interface is not None else ''
3256        '''
3257         Bind interface
3258        '''
3259        self.egress_filter = egress_filter if egress_filter is not None else ''
3260        '''
3261         A filter applied to the routing logic to pin datasource to nodes.
3262        '''
3263        self.healthy = healthy if healthy is not None else False
3264        '''
3265         True if the datasource is reachable and the credentials are valid.
3266        '''
3267        self.hostname = hostname if hostname is not None else ''
3268        '''
3269
3270        '''
3271        self.id = id if id is not None else ''
3272        '''
3273         Unique identifier of the Resource.
3274        '''
3275        self.name = name if name is not None else ''
3276        '''
3277         Unique human-readable name of the Resource.
3278        '''
3279        self.password = password if password is not None else ''
3280        '''
3281
3282        '''
3283        self.port = port if port is not None else 0
3284        '''
3285
3286        '''
3287        self.port_override = port_override if port_override is not None else 0
3288        '''
3289
3290        '''
3291        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3292        '''
3293         ID of the secret store containing credentials for this resource, if any.
3294        '''
3295        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3296        '''
3297         Tags is a map of key, value pairs.
3298        '''
3299        self.tls_required = tls_required if tls_required is not None else False
3300        '''
3301
3302        '''
3303        self.username = username if username is not None else ''
3304        '''
3305
3306        '''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
3325    def to_dict(self):
3326        return {
3327            'bind_interface': self.bind_interface,
3328            'egress_filter': self.egress_filter,
3329            'healthy': self.healthy,
3330            'hostname': self.hostname,
3331            'id': self.id,
3332            'name': self.name,
3333            'password': self.password,
3334            'port': self.port,
3335            'port_override': self.port_override,
3336            'secret_store_id': self.secret_store_id,
3337            'tags': self.tags,
3338            'tls_required': self.tls_required,
3339            'username': self.username,
3340        }
@classmethod
def from_dict(cls, d)
3342    @classmethod
3343    def from_dict(cls, d):
3344        return cls(
3345            bind_interface=d.get('bind_interface'),
3346            egress_filter=d.get('egress_filter'),
3347            healthy=d.get('healthy'),
3348            hostname=d.get('hostname'),
3349            id=d.get('id'),
3350            name=d.get('name'),
3351            password=d.get('password'),
3352            port=d.get('port'),
3353            port_override=d.get('port_override'),
3354            secret_store_id=d.get('secret_store_id'),
3355            tags=d.get('tags'),
3356            tls_required=d.get('tls_required'),
3357            username=d.get('username'),
3358        )
class Citus:
3361class Citus:
3362    '''
3363
3364    '''
3365    __slots__ = [
3366        'bind_interface',
3367        'database',
3368        'egress_filter',
3369        'healthy',
3370        'hostname',
3371        'id',
3372        'name',
3373        'override_database',
3374        'password',
3375        'port',
3376        'port_override',
3377        'secret_store_id',
3378        'tags',
3379        'username',
3380    ]
3381
3382    def __init__(
3383        self,
3384        bind_interface=None,
3385        database=None,
3386        egress_filter=None,
3387        healthy=None,
3388        hostname=None,
3389        id=None,
3390        name=None,
3391        override_database=None,
3392        password=None,
3393        port=None,
3394        port_override=None,
3395        secret_store_id=None,
3396        tags=None,
3397        username=None,
3398    ):
3399        self.bind_interface = bind_interface if bind_interface is not None else ''
3400        '''
3401         Bind interface
3402        '''
3403        self.database = database if database is not None else ''
3404        '''
3405
3406        '''
3407        self.egress_filter = egress_filter if egress_filter is not None else ''
3408        '''
3409         A filter applied to the routing logic to pin datasource to nodes.
3410        '''
3411        self.healthy = healthy if healthy is not None else False
3412        '''
3413         True if the datasource is reachable and the credentials are valid.
3414        '''
3415        self.hostname = hostname if hostname is not None else ''
3416        '''
3417
3418        '''
3419        self.id = id if id is not None else ''
3420        '''
3421         Unique identifier of the Resource.
3422        '''
3423        self.name = name if name is not None else ''
3424        '''
3425         Unique human-readable name of the Resource.
3426        '''
3427        self.override_database = override_database if override_database is not None else False
3428        '''
3429
3430        '''
3431        self.password = password if password is not None else ''
3432        '''
3433
3434        '''
3435        self.port = port if port is not None else 0
3436        '''
3437
3438        '''
3439        self.port_override = port_override if port_override is not None else 0
3440        '''
3441
3442        '''
3443        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3444        '''
3445         ID of the secret store containing credentials for this resource, if any.
3446        '''
3447        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3448        '''
3449         Tags is a map of key, value pairs.
3450        '''
3451        self.username = username if username is not None else ''
3452        '''
3453
3454        '''
3455
3456    def __repr__(self):
3457        return '<sdm.Citus ' + \
3458            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
3459            'database: ' + repr(self.database) + ' ' +\
3460            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
3461            'healthy: ' + repr(self.healthy) + ' ' +\
3462            'hostname: ' + repr(self.hostname) + ' ' +\
3463            'id: ' + repr(self.id) + ' ' +\
3464            'name: ' + repr(self.name) + ' ' +\
3465            'override_database: ' + repr(self.override_database) + ' ' +\
3466            'password: ' + repr(self.password) + ' ' +\
3467            'port: ' + repr(self.port) + ' ' +\
3468            'port_override: ' + repr(self.port_override) + ' ' +\
3469            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
3470            'tags: ' + repr(self.tags) + ' ' +\
3471            'username: ' + repr(self.username) + ' ' +\
3472            '>'
3473
3474    def to_dict(self):
3475        return {
3476            'bind_interface': self.bind_interface,
3477            'database': self.database,
3478            'egress_filter': self.egress_filter,
3479            'healthy': self.healthy,
3480            'hostname': self.hostname,
3481            'id': self.id,
3482            'name': self.name,
3483            'override_database': self.override_database,
3484            'password': self.password,
3485            'port': self.port,
3486            'port_override': self.port_override,
3487            'secret_store_id': self.secret_store_id,
3488            'tags': self.tags,
3489            'username': self.username,
3490        }
3491
3492    @classmethod
3493    def from_dict(cls, d):
3494        return cls(
3495            bind_interface=d.get('bind_interface'),
3496            database=d.get('database'),
3497            egress_filter=d.get('egress_filter'),
3498            healthy=d.get('healthy'),
3499            hostname=d.get('hostname'),
3500            id=d.get('id'),
3501            name=d.get('name'),
3502            override_database=d.get('override_database'),
3503            password=d.get('password'),
3504            port=d.get('port'),
3505            port_override=d.get('port_override'),
3506            secret_store_id=d.get('secret_store_id'),
3507            tags=d.get('tags'),
3508            username=d.get('username'),
3509        )
Citus( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, override_database=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
3382    def __init__(
3383        self,
3384        bind_interface=None,
3385        database=None,
3386        egress_filter=None,
3387        healthy=None,
3388        hostname=None,
3389        id=None,
3390        name=None,
3391        override_database=None,
3392        password=None,
3393        port=None,
3394        port_override=None,
3395        secret_store_id=None,
3396        tags=None,
3397        username=None,
3398    ):
3399        self.bind_interface = bind_interface if bind_interface is not None else ''
3400        '''
3401         Bind interface
3402        '''
3403        self.database = database if database is not None else ''
3404        '''
3405
3406        '''
3407        self.egress_filter = egress_filter if egress_filter is not None else ''
3408        '''
3409         A filter applied to the routing logic to pin datasource to nodes.
3410        '''
3411        self.healthy = healthy if healthy is not None else False
3412        '''
3413         True if the datasource is reachable and the credentials are valid.
3414        '''
3415        self.hostname = hostname if hostname is not None else ''
3416        '''
3417
3418        '''
3419        self.id = id if id is not None else ''
3420        '''
3421         Unique identifier of the Resource.
3422        '''
3423        self.name = name if name is not None else ''
3424        '''
3425         Unique human-readable name of the Resource.
3426        '''
3427        self.override_database = override_database if override_database is not None else False
3428        '''
3429
3430        '''
3431        self.password = password if password is not None else ''
3432        '''
3433
3434        '''
3435        self.port = port if port is not None else 0
3436        '''
3437
3438        '''
3439        self.port_override = port_override if port_override is not None else 0
3440        '''
3441
3442        '''
3443        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3444        '''
3445         ID of the secret store containing credentials for this resource, if any.
3446        '''
3447        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3448        '''
3449         Tags is a map of key, value pairs.
3450        '''
3451        self.username = username if username is not None else ''
3452        '''
3453
3454        '''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

override_database
password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
3474    def to_dict(self):
3475        return {
3476            'bind_interface': self.bind_interface,
3477            'database': self.database,
3478            'egress_filter': self.egress_filter,
3479            'healthy': self.healthy,
3480            'hostname': self.hostname,
3481            'id': self.id,
3482            'name': self.name,
3483            'override_database': self.override_database,
3484            'password': self.password,
3485            'port': self.port,
3486            'port_override': self.port_override,
3487            'secret_store_id': self.secret_store_id,
3488            'tags': self.tags,
3489            'username': self.username,
3490        }
@classmethod
def from_dict(cls, d)
3492    @classmethod
3493    def from_dict(cls, d):
3494        return cls(
3495            bind_interface=d.get('bind_interface'),
3496            database=d.get('database'),
3497            egress_filter=d.get('egress_filter'),
3498            healthy=d.get('healthy'),
3499            hostname=d.get('hostname'),
3500            id=d.get('id'),
3501            name=d.get('name'),
3502            override_database=d.get('override_database'),
3503            password=d.get('password'),
3504            port=d.get('port'),
3505            port_override=d.get('port_override'),
3506            secret_store_id=d.get('secret_store_id'),
3507            tags=d.get('tags'),
3508            username=d.get('username'),
3509        )
class Clustrix:
3512class Clustrix:
3513    '''
3514
3515    '''
3516    __slots__ = [
3517        'bind_interface',
3518        'database',
3519        'egress_filter',
3520        'healthy',
3521        'hostname',
3522        'id',
3523        'name',
3524        'password',
3525        'port',
3526        'port_override',
3527        'secret_store_id',
3528        'tags',
3529        'username',
3530    ]
3531
3532    def __init__(
3533        self,
3534        bind_interface=None,
3535        database=None,
3536        egress_filter=None,
3537        healthy=None,
3538        hostname=None,
3539        id=None,
3540        name=None,
3541        password=None,
3542        port=None,
3543        port_override=None,
3544        secret_store_id=None,
3545        tags=None,
3546        username=None,
3547    ):
3548        self.bind_interface = bind_interface if bind_interface is not None else ''
3549        '''
3550         Bind interface
3551        '''
3552        self.database = database if database is not None else ''
3553        '''
3554
3555        '''
3556        self.egress_filter = egress_filter if egress_filter is not None else ''
3557        '''
3558         A filter applied to the routing logic to pin datasource to nodes.
3559        '''
3560        self.healthy = healthy if healthy is not None else False
3561        '''
3562         True if the datasource is reachable and the credentials are valid.
3563        '''
3564        self.hostname = hostname if hostname is not None else ''
3565        '''
3566
3567        '''
3568        self.id = id if id is not None else ''
3569        '''
3570         Unique identifier of the Resource.
3571        '''
3572        self.name = name if name is not None else ''
3573        '''
3574         Unique human-readable name of the Resource.
3575        '''
3576        self.password = password if password is not None else ''
3577        '''
3578
3579        '''
3580        self.port = port if port is not None else 0
3581        '''
3582
3583        '''
3584        self.port_override = port_override if port_override is not None else 0
3585        '''
3586
3587        '''
3588        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3589        '''
3590         ID of the secret store containing credentials for this resource, if any.
3591        '''
3592        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3593        '''
3594         Tags is a map of key, value pairs.
3595        '''
3596        self.username = username if username is not None else ''
3597        '''
3598
3599        '''
3600
3601    def __repr__(self):
3602        return '<sdm.Clustrix ' + \
3603            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
3604            'database: ' + repr(self.database) + ' ' +\
3605            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
3606            'healthy: ' + repr(self.healthy) + ' ' +\
3607            'hostname: ' + repr(self.hostname) + ' ' +\
3608            'id: ' + repr(self.id) + ' ' +\
3609            'name: ' + repr(self.name) + ' ' +\
3610            'password: ' + repr(self.password) + ' ' +\
3611            'port: ' + repr(self.port) + ' ' +\
3612            'port_override: ' + repr(self.port_override) + ' ' +\
3613            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
3614            'tags: ' + repr(self.tags) + ' ' +\
3615            'username: ' + repr(self.username) + ' ' +\
3616            '>'
3617
3618    def to_dict(self):
3619        return {
3620            'bind_interface': self.bind_interface,
3621            'database': self.database,
3622            'egress_filter': self.egress_filter,
3623            'healthy': self.healthy,
3624            'hostname': self.hostname,
3625            'id': self.id,
3626            'name': self.name,
3627            'password': self.password,
3628            'port': self.port,
3629            'port_override': self.port_override,
3630            'secret_store_id': self.secret_store_id,
3631            'tags': self.tags,
3632            'username': self.username,
3633        }
3634
3635    @classmethod
3636    def from_dict(cls, d):
3637        return cls(
3638            bind_interface=d.get('bind_interface'),
3639            database=d.get('database'),
3640            egress_filter=d.get('egress_filter'),
3641            healthy=d.get('healthy'),
3642            hostname=d.get('hostname'),
3643            id=d.get('id'),
3644            name=d.get('name'),
3645            password=d.get('password'),
3646            port=d.get('port'),
3647            port_override=d.get('port_override'),
3648            secret_store_id=d.get('secret_store_id'),
3649            tags=d.get('tags'),
3650            username=d.get('username'),
3651        )
Clustrix( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
3532    def __init__(
3533        self,
3534        bind_interface=None,
3535        database=None,
3536        egress_filter=None,
3537        healthy=None,
3538        hostname=None,
3539        id=None,
3540        name=None,
3541        password=None,
3542        port=None,
3543        port_override=None,
3544        secret_store_id=None,
3545        tags=None,
3546        username=None,
3547    ):
3548        self.bind_interface = bind_interface if bind_interface is not None else ''
3549        '''
3550         Bind interface
3551        '''
3552        self.database = database if database is not None else ''
3553        '''
3554
3555        '''
3556        self.egress_filter = egress_filter if egress_filter is not None else ''
3557        '''
3558         A filter applied to the routing logic to pin datasource to nodes.
3559        '''
3560        self.healthy = healthy if healthy is not None else False
3561        '''
3562         True if the datasource is reachable and the credentials are valid.
3563        '''
3564        self.hostname = hostname if hostname is not None else ''
3565        '''
3566
3567        '''
3568        self.id = id if id is not None else ''
3569        '''
3570         Unique identifier of the Resource.
3571        '''
3572        self.name = name if name is not None else ''
3573        '''
3574         Unique human-readable name of the Resource.
3575        '''
3576        self.password = password if password is not None else ''
3577        '''
3578
3579        '''
3580        self.port = port if port is not None else 0
3581        '''
3582
3583        '''
3584        self.port_override = port_override if port_override is not None else 0
3585        '''
3586
3587        '''
3588        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3589        '''
3590         ID of the secret store containing credentials for this resource, if any.
3591        '''
3592        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3593        '''
3594         Tags is a map of key, value pairs.
3595        '''
3596        self.username = username if username is not None else ''
3597        '''
3598
3599        '''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
3618    def to_dict(self):
3619        return {
3620            'bind_interface': self.bind_interface,
3621            'database': self.database,
3622            'egress_filter': self.egress_filter,
3623            'healthy': self.healthy,
3624            'hostname': self.hostname,
3625            'id': self.id,
3626            'name': self.name,
3627            'password': self.password,
3628            'port': self.port,
3629            'port_override': self.port_override,
3630            'secret_store_id': self.secret_store_id,
3631            'tags': self.tags,
3632            'username': self.username,
3633        }
@classmethod
def from_dict(cls, d)
3635    @classmethod
3636    def from_dict(cls, d):
3637        return cls(
3638            bind_interface=d.get('bind_interface'),
3639            database=d.get('database'),
3640            egress_filter=d.get('egress_filter'),
3641            healthy=d.get('healthy'),
3642            hostname=d.get('hostname'),
3643            id=d.get('id'),
3644            name=d.get('name'),
3645            password=d.get('password'),
3646            port=d.get('port'),
3647            port_override=d.get('port_override'),
3648            secret_store_id=d.get('secret_store_id'),
3649            tags=d.get('tags'),
3650            username=d.get('username'),
3651        )
class Cockroach:
3654class Cockroach:
3655    '''
3656
3657    '''
3658    __slots__ = [
3659        'bind_interface',
3660        'database',
3661        'egress_filter',
3662        'healthy',
3663        'hostname',
3664        'id',
3665        'name',
3666        'override_database',
3667        'password',
3668        'port',
3669        'port_override',
3670        'secret_store_id',
3671        'tags',
3672        'username',
3673    ]
3674
3675    def __init__(
3676        self,
3677        bind_interface=None,
3678        database=None,
3679        egress_filter=None,
3680        healthy=None,
3681        hostname=None,
3682        id=None,
3683        name=None,
3684        override_database=None,
3685        password=None,
3686        port=None,
3687        port_override=None,
3688        secret_store_id=None,
3689        tags=None,
3690        username=None,
3691    ):
3692        self.bind_interface = bind_interface if bind_interface is not None else ''
3693        '''
3694         Bind interface
3695        '''
3696        self.database = database if database is not None else ''
3697        '''
3698
3699        '''
3700        self.egress_filter = egress_filter if egress_filter is not None else ''
3701        '''
3702         A filter applied to the routing logic to pin datasource to nodes.
3703        '''
3704        self.healthy = healthy if healthy is not None else False
3705        '''
3706         True if the datasource is reachable and the credentials are valid.
3707        '''
3708        self.hostname = hostname if hostname is not None else ''
3709        '''
3710
3711        '''
3712        self.id = id if id is not None else ''
3713        '''
3714         Unique identifier of the Resource.
3715        '''
3716        self.name = name if name is not None else ''
3717        '''
3718         Unique human-readable name of the Resource.
3719        '''
3720        self.override_database = override_database if override_database is not None else False
3721        '''
3722
3723        '''
3724        self.password = password if password is not None else ''
3725        '''
3726
3727        '''
3728        self.port = port if port is not None else 0
3729        '''
3730
3731        '''
3732        self.port_override = port_override if port_override is not None else 0
3733        '''
3734
3735        '''
3736        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3737        '''
3738         ID of the secret store containing credentials for this resource, if any.
3739        '''
3740        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3741        '''
3742         Tags is a map of key, value pairs.
3743        '''
3744        self.username = username if username is not None else ''
3745        '''
3746
3747        '''
3748
3749    def __repr__(self):
3750        return '<sdm.Cockroach ' + \
3751            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
3752            'database: ' + repr(self.database) + ' ' +\
3753            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
3754            'healthy: ' + repr(self.healthy) + ' ' +\
3755            'hostname: ' + repr(self.hostname) + ' ' +\
3756            'id: ' + repr(self.id) + ' ' +\
3757            'name: ' + repr(self.name) + ' ' +\
3758            'override_database: ' + repr(self.override_database) + ' ' +\
3759            'password: ' + repr(self.password) + ' ' +\
3760            'port: ' + repr(self.port) + ' ' +\
3761            'port_override: ' + repr(self.port_override) + ' ' +\
3762            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
3763            'tags: ' + repr(self.tags) + ' ' +\
3764            'username: ' + repr(self.username) + ' ' +\
3765            '>'
3766
3767    def to_dict(self):
3768        return {
3769            'bind_interface': self.bind_interface,
3770            'database': self.database,
3771            'egress_filter': self.egress_filter,
3772            'healthy': self.healthy,
3773            'hostname': self.hostname,
3774            'id': self.id,
3775            'name': self.name,
3776            'override_database': self.override_database,
3777            'password': self.password,
3778            'port': self.port,
3779            'port_override': self.port_override,
3780            'secret_store_id': self.secret_store_id,
3781            'tags': self.tags,
3782            'username': self.username,
3783        }
3784
3785    @classmethod
3786    def from_dict(cls, d):
3787        return cls(
3788            bind_interface=d.get('bind_interface'),
3789            database=d.get('database'),
3790            egress_filter=d.get('egress_filter'),
3791            healthy=d.get('healthy'),
3792            hostname=d.get('hostname'),
3793            id=d.get('id'),
3794            name=d.get('name'),
3795            override_database=d.get('override_database'),
3796            password=d.get('password'),
3797            port=d.get('port'),
3798            port_override=d.get('port_override'),
3799            secret_store_id=d.get('secret_store_id'),
3800            tags=d.get('tags'),
3801            username=d.get('username'),
3802        )
Cockroach( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, override_database=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
3675    def __init__(
3676        self,
3677        bind_interface=None,
3678        database=None,
3679        egress_filter=None,
3680        healthy=None,
3681        hostname=None,
3682        id=None,
3683        name=None,
3684        override_database=None,
3685        password=None,
3686        port=None,
3687        port_override=None,
3688        secret_store_id=None,
3689        tags=None,
3690        username=None,
3691    ):
3692        self.bind_interface = bind_interface if bind_interface is not None else ''
3693        '''
3694         Bind interface
3695        '''
3696        self.database = database if database is not None else ''
3697        '''
3698
3699        '''
3700        self.egress_filter = egress_filter if egress_filter is not None else ''
3701        '''
3702         A filter applied to the routing logic to pin datasource to nodes.
3703        '''
3704        self.healthy = healthy if healthy is not None else False
3705        '''
3706         True if the datasource is reachable and the credentials are valid.
3707        '''
3708        self.hostname = hostname if hostname is not None else ''
3709        '''
3710
3711        '''
3712        self.id = id if id is not None else ''
3713        '''
3714         Unique identifier of the Resource.
3715        '''
3716        self.name = name if name is not None else ''
3717        '''
3718         Unique human-readable name of the Resource.
3719        '''
3720        self.override_database = override_database if override_database is not None else False
3721        '''
3722
3723        '''
3724        self.password = password if password is not None else ''
3725        '''
3726
3727        '''
3728        self.port = port if port is not None else 0
3729        '''
3730
3731        '''
3732        self.port_override = port_override if port_override is not None else 0
3733        '''
3734
3735        '''
3736        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
3737        '''
3738         ID of the secret store containing credentials for this resource, if any.
3739        '''
3740        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
3741        '''
3742         Tags is a map of key, value pairs.
3743        '''
3744        self.username = username if username is not None else ''
3745        '''
3746
3747        '''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

override_database
password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
3767    def to_dict(self):
3768        return {
3769            'bind_interface': self.bind_interface,
3770            'database': self.database,
3771            'egress_filter': self.egress_filter,
3772            'healthy': self.healthy,
3773            'hostname': self.hostname,
3774            'id': self.id,
3775            'name': self.name,
3776            'override_database': self.override_database,
3777            'password': self.password,
3778            'port': self.port,
3779            'port_override': self.port_override,
3780            'secret_store_id': self.secret_store_id,
3781            'tags': self.tags,
3782            'username': self.username,
3783        }
@classmethod
def from_dict(cls, d)
3785    @classmethod
3786    def from_dict(cls, d):
3787        return cls(
3788            bind_interface=d.get('bind_interface'),
3789            database=d.get('database'),
3790            egress_filter=d.get('egress_filter'),
3791            healthy=d.get('healthy'),
3792            hostname=d.get('hostname'),
3793            id=d.get('id'),
3794            name=d.get('name'),
3795            override_database=d.get('override_database'),
3796            password=d.get('password'),
3797            port=d.get('port'),
3798            port_override=d.get('port_override'),
3799            secret_store_id=d.get('secret_store_id'),
3800            tags=d.get('tags'),
3801            username=d.get('username'),
3802        )
class ControlPanelGetSSHCAPublicKeyResponse:
3805class ControlPanelGetSSHCAPublicKeyResponse:
3806    '''
3807     ControlPanelGetSSHCAPublicKeyResponse represents a request for an
3808     organization's SSH Certificate Authority public key.
3809    '''
3810    __slots__ = [
3811        'meta',
3812        'public_key',
3813        'rate_limit',
3814    ]
3815
3816    def __init__(
3817        self,
3818        meta=None,
3819        public_key=None,
3820        rate_limit=None,
3821    ):
3822        self.meta = meta if meta is not None else None
3823        '''
3824         Reserved for future use.
3825        '''
3826        self.public_key = public_key if public_key is not None else ''
3827        '''
3828         The public key of the SSH Certificate Authority, in OpenSSH RSA public
3829         key format.
3830        '''
3831        self.rate_limit = rate_limit if rate_limit is not None else None
3832        '''
3833         Rate limit information.
3834        '''
3835
3836    def __repr__(self):
3837        return '<sdm.ControlPanelGetSSHCAPublicKeyResponse ' + \
3838            'meta: ' + repr(self.meta) + ' ' +\
3839            'public_key: ' + repr(self.public_key) + ' ' +\
3840            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
3841            '>'
3842
3843    def to_dict(self):
3844        return {
3845            'meta': self.meta,
3846            'public_key': self.public_key,
3847            'rate_limit': self.rate_limit,
3848        }
3849
3850    @classmethod
3851    def from_dict(cls, d):
3852        return cls(
3853            meta=d.get('meta'),
3854            public_key=d.get('public_key'),
3855            rate_limit=d.get('rate_limit'),
3856        )

ControlPanelGetSSHCAPublicKeyResponse represents a request for an organization's SSH Certificate Authority public key.

ControlPanelGetSSHCAPublicKeyResponse(meta=None, public_key=None, rate_limit=None)
3816    def __init__(
3817        self,
3818        meta=None,
3819        public_key=None,
3820        rate_limit=None,
3821    ):
3822        self.meta = meta if meta is not None else None
3823        '''
3824         Reserved for future use.
3825        '''
3826        self.public_key = public_key if public_key is not None else ''
3827        '''
3828         The public key of the SSH Certificate Authority, in OpenSSH RSA public
3829         key format.
3830        '''
3831        self.rate_limit = rate_limit if rate_limit is not None else None
3832        '''
3833         Rate limit information.
3834        '''
meta

Reserved for future use.

public_key

The public key of the SSH Certificate Authority, in OpenSSH RSA public key format.

rate_limit

Rate limit information.

def to_dict(self)
3843    def to_dict(self):
3844        return {
3845            'meta': self.meta,
3846            'public_key': self.public_key,
3847            'rate_limit': self.rate_limit,
3848        }
@classmethod
def from_dict(cls, d)
3850    @classmethod
3851    def from_dict(cls, d):
3852        return cls(
3853            meta=d.get('meta'),
3854            public_key=d.get('public_key'),
3855            rate_limit=d.get('rate_limit'),
3856        )
class ControlPanelVerifyJWTResponse:
3859class ControlPanelVerifyJWTResponse:
3860    '''
3861     ControlPanelVerifyJWTResponse reports whether x-sdm-token is valid.
3862    '''
3863    __slots__ = [
3864        'meta',
3865        'rate_limit',
3866        'valid',
3867    ]
3868
3869    def __init__(
3870        self,
3871        meta=None,
3872        rate_limit=None,
3873        valid=None,
3874    ):
3875        self.meta = meta if meta is not None else None
3876        '''
3877         Reserved for future use.
3878        '''
3879        self.rate_limit = rate_limit if rate_limit is not None else None
3880        '''
3881         Rate limit information.
3882        '''
3883        self.valid = valid if valid is not None else False
3884        '''
3885         Reports if the given token is valid.
3886        '''
3887
3888    def __repr__(self):
3889        return '<sdm.ControlPanelVerifyJWTResponse ' + \
3890            'meta: ' + repr(self.meta) + ' ' +\
3891            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
3892            'valid: ' + repr(self.valid) + ' ' +\
3893            '>'
3894
3895    def to_dict(self):
3896        return {
3897            'meta': self.meta,
3898            'rate_limit': self.rate_limit,
3899            'valid': self.valid,
3900        }
3901
3902    @classmethod
3903    def from_dict(cls, d):
3904        return cls(
3905            meta=d.get('meta'),
3906            rate_limit=d.get('rate_limit'),
3907            valid=d.get('valid'),
3908        )

ControlPanelVerifyJWTResponse reports whether x-sdm-token is valid.

ControlPanelVerifyJWTResponse(meta=None, rate_limit=None, valid=None)
3869    def __init__(
3870        self,
3871        meta=None,
3872        rate_limit=None,
3873        valid=None,
3874    ):
3875        self.meta = meta if meta is not None else None
3876        '''
3877         Reserved for future use.
3878        '''
3879        self.rate_limit = rate_limit if rate_limit is not None else None
3880        '''
3881         Rate limit information.
3882        '''
3883        self.valid = valid if valid is not None else False
3884        '''
3885         Reports if the given token is valid.
3886        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

valid

Reports if the given token is valid.

def to_dict(self)
3895    def to_dict(self):
3896        return {
3897            'meta': self.meta,
3898            'rate_limit': self.rate_limit,
3899            'valid': self.valid,
3900        }
@classmethod
def from_dict(cls, d)
3902    @classmethod
3903    def from_dict(cls, d):
3904        return cls(
3905            meta=d.get('meta'),
3906            rate_limit=d.get('rate_limit'),
3907            valid=d.get('valid'),
3908        )
class CreateResponseMetadata:
3911class CreateResponseMetadata:
3912    '''
3913     CreateResponseMetadata is reserved for future use.
3914    '''
3915    __slots__ = []
3916
3917    def __init__(self, ):
3918        pass
3919
3920    def __repr__(self):
3921        return '<sdm.CreateResponseMetadata ' + \
3922            '>'
3923
3924    def to_dict(self):
3925        return {}
3926
3927    @classmethod
3928    def from_dict(cls, d):
3929        return cls()

CreateResponseMetadata is reserved for future use.

CreateResponseMetadata()
3917    def __init__(self, ):
3918        pass
def to_dict(self)
3924    def to_dict(self):
3925        return {}
@classmethod
def from_dict(cls, d)
3927    @classmethod
3928    def from_dict(cls, d):
3929        return cls()
class DB2I:
3932class DB2I:
3933    '''
3934
3935    '''
3936    __slots__ = [
3937        'bind_interface',
3938        'egress_filter',
3939        'healthy',
3940        'hostname',
3941        'id',
3942        'name',
3943        'password',
3944        'port',
3945        'port_override',
3946        'secret_store_id',
3947        'tags',
3948        'tls_required',
3949        'username',
3950    ]
3951
3952    def __init__(
3953        self,
3954        bind_interface=None,
3955        egress_filter=None,
3956        healthy=None,
3957        hostname=None,
3958        id=None,
3959        name=None,
3960        password=None,
3961        port=None,
3962        port_override=None,
3963        secret_store_id=None,
3964        tags=None,
3965        tls_required=None,
3966        username=None,
3967    ):
3968        self.bind_interface = bind_interface if bind_interface is not None else ''
3969        '''
3970         Bind interface
3971        '''
3972        self.egress_filter = egress_filter if egress_filter is not None else ''
3973        '''
3974         A filter applied to the routing logic to pin datasource to nodes.
3975        '''
3976        self.healthy = healthy if healthy is not None else False
3977        '''
3978         True if the datasource is reachable and the credentials are valid.
3979        '''
3980        self.hostname = hostname if hostname is not None else ''
3981        '''
3982
3983        '''
3984        self.id = id if id is not None else ''
3985        '''
3986         Unique identifier of the Resource.
3987        '''
3988        self.name = name if name is not None else ''
3989        '''
3990         Unique human-readable name of the Resource.
3991        '''
3992        self.password = password if password is not None else ''
3993        '''
3994
3995        '''
3996        self.port = port if port is not None else 0
3997        '''
3998
3999        '''
4000        self.port_override = port_override if port_override is not None else 0
4001        '''
4002
4003        '''
4004        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4005        '''
4006         ID of the secret store containing credentials for this resource, if any.
4007        '''
4008        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4009        '''
4010         Tags is a map of key, value pairs.
4011        '''
4012        self.tls_required = tls_required if tls_required is not None else False
4013        '''
4014
4015        '''
4016        self.username = username if username is not None else ''
4017        '''
4018
4019        '''
4020
4021    def __repr__(self):
4022        return '<sdm.DB2I ' + \
4023            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
4024            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
4025            'healthy: ' + repr(self.healthy) + ' ' +\
4026            'hostname: ' + repr(self.hostname) + ' ' +\
4027            'id: ' + repr(self.id) + ' ' +\
4028            'name: ' + repr(self.name) + ' ' +\
4029            'password: ' + repr(self.password) + ' ' +\
4030            'port: ' + repr(self.port) + ' ' +\
4031            'port_override: ' + repr(self.port_override) + ' ' +\
4032            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
4033            'tags: ' + repr(self.tags) + ' ' +\
4034            'tls_required: ' + repr(self.tls_required) + ' ' +\
4035            'username: ' + repr(self.username) + ' ' +\
4036            '>'
4037
4038    def to_dict(self):
4039        return {
4040            'bind_interface': self.bind_interface,
4041            'egress_filter': self.egress_filter,
4042            'healthy': self.healthy,
4043            'hostname': self.hostname,
4044            'id': self.id,
4045            'name': self.name,
4046            'password': self.password,
4047            'port': self.port,
4048            'port_override': self.port_override,
4049            'secret_store_id': self.secret_store_id,
4050            'tags': self.tags,
4051            'tls_required': self.tls_required,
4052            'username': self.username,
4053        }
4054
4055    @classmethod
4056    def from_dict(cls, d):
4057        return cls(
4058            bind_interface=d.get('bind_interface'),
4059            egress_filter=d.get('egress_filter'),
4060            healthy=d.get('healthy'),
4061            hostname=d.get('hostname'),
4062            id=d.get('id'),
4063            name=d.get('name'),
4064            password=d.get('password'),
4065            port=d.get('port'),
4066            port_override=d.get('port_override'),
4067            secret_store_id=d.get('secret_store_id'),
4068            tags=d.get('tags'),
4069            tls_required=d.get('tls_required'),
4070            username=d.get('username'),
4071        )
DB2I( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, tls_required=None, username=None)
3952    def __init__(
3953        self,
3954        bind_interface=None,
3955        egress_filter=None,
3956        healthy=None,
3957        hostname=None,
3958        id=None,
3959        name=None,
3960        password=None,
3961        port=None,
3962        port_override=None,
3963        secret_store_id=None,
3964        tags=None,
3965        tls_required=None,
3966        username=None,
3967    ):
3968        self.bind_interface = bind_interface if bind_interface is not None else ''
3969        '''
3970         Bind interface
3971        '''
3972        self.egress_filter = egress_filter if egress_filter is not None else ''
3973        '''
3974         A filter applied to the routing logic to pin datasource to nodes.
3975        '''
3976        self.healthy = healthy if healthy is not None else False
3977        '''
3978         True if the datasource is reachable and the credentials are valid.
3979        '''
3980        self.hostname = hostname if hostname is not None else ''
3981        '''
3982
3983        '''
3984        self.id = id if id is not None else ''
3985        '''
3986         Unique identifier of the Resource.
3987        '''
3988        self.name = name if name is not None else ''
3989        '''
3990         Unique human-readable name of the Resource.
3991        '''
3992        self.password = password if password is not None else ''
3993        '''
3994
3995        '''
3996        self.port = port if port is not None else 0
3997        '''
3998
3999        '''
4000        self.port_override = port_override if port_override is not None else 0
4001        '''
4002
4003        '''
4004        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4005        '''
4006         ID of the secret store containing credentials for this resource, if any.
4007        '''
4008        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4009        '''
4010         Tags is a map of key, value pairs.
4011        '''
4012        self.tls_required = tls_required if tls_required is not None else False
4013        '''
4014
4015        '''
4016        self.username = username if username is not None else ''
4017        '''
4018
4019        '''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
4038    def to_dict(self):
4039        return {
4040            'bind_interface': self.bind_interface,
4041            'egress_filter': self.egress_filter,
4042            'healthy': self.healthy,
4043            'hostname': self.hostname,
4044            'id': self.id,
4045            'name': self.name,
4046            'password': self.password,
4047            'port': self.port,
4048            'port_override': self.port_override,
4049            'secret_store_id': self.secret_store_id,
4050            'tags': self.tags,
4051            'tls_required': self.tls_required,
4052            'username': self.username,
4053        }
@classmethod
def from_dict(cls, d)
4055    @classmethod
4056    def from_dict(cls, d):
4057        return cls(
4058            bind_interface=d.get('bind_interface'),
4059            egress_filter=d.get('egress_filter'),
4060            healthy=d.get('healthy'),
4061            hostname=d.get('hostname'),
4062            id=d.get('id'),
4063            name=d.get('name'),
4064            password=d.get('password'),
4065            port=d.get('port'),
4066            port_override=d.get('port_override'),
4067            secret_store_id=d.get('secret_store_id'),
4068            tags=d.get('tags'),
4069            tls_required=d.get('tls_required'),
4070            username=d.get('username'),
4071        )
class DB2LUW:
4074class DB2LUW:
4075    '''
4076
4077    '''
4078    __slots__ = [
4079        'bind_interface',
4080        'database',
4081        'egress_filter',
4082        'healthy',
4083        'hostname',
4084        'id',
4085        'name',
4086        'password',
4087        'port',
4088        'port_override',
4089        'secret_store_id',
4090        'tags',
4091        'username',
4092    ]
4093
4094    def __init__(
4095        self,
4096        bind_interface=None,
4097        database=None,
4098        egress_filter=None,
4099        healthy=None,
4100        hostname=None,
4101        id=None,
4102        name=None,
4103        password=None,
4104        port=None,
4105        port_override=None,
4106        secret_store_id=None,
4107        tags=None,
4108        username=None,
4109    ):
4110        self.bind_interface = bind_interface if bind_interface is not None else ''
4111        '''
4112         Bind interface
4113        '''
4114        self.database = database if database is not None else ''
4115        '''
4116
4117        '''
4118        self.egress_filter = egress_filter if egress_filter is not None else ''
4119        '''
4120         A filter applied to the routing logic to pin datasource to nodes.
4121        '''
4122        self.healthy = healthy if healthy is not None else False
4123        '''
4124         True if the datasource is reachable and the credentials are valid.
4125        '''
4126        self.hostname = hostname if hostname is not None else ''
4127        '''
4128
4129        '''
4130        self.id = id if id is not None else ''
4131        '''
4132         Unique identifier of the Resource.
4133        '''
4134        self.name = name if name is not None else ''
4135        '''
4136         Unique human-readable name of the Resource.
4137        '''
4138        self.password = password if password is not None else ''
4139        '''
4140
4141        '''
4142        self.port = port if port is not None else 0
4143        '''
4144
4145        '''
4146        self.port_override = port_override if port_override is not None else 0
4147        '''
4148
4149        '''
4150        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4151        '''
4152         ID of the secret store containing credentials for this resource, if any.
4153        '''
4154        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4155        '''
4156         Tags is a map of key, value pairs.
4157        '''
4158        self.username = username if username is not None else ''
4159        '''
4160
4161        '''
4162
4163    def __repr__(self):
4164        return '<sdm.DB2LUW ' + \
4165            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
4166            'database: ' + repr(self.database) + ' ' +\
4167            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
4168            'healthy: ' + repr(self.healthy) + ' ' +\
4169            'hostname: ' + repr(self.hostname) + ' ' +\
4170            'id: ' + repr(self.id) + ' ' +\
4171            'name: ' + repr(self.name) + ' ' +\
4172            'password: ' + repr(self.password) + ' ' +\
4173            'port: ' + repr(self.port) + ' ' +\
4174            'port_override: ' + repr(self.port_override) + ' ' +\
4175            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
4176            'tags: ' + repr(self.tags) + ' ' +\
4177            'username: ' + repr(self.username) + ' ' +\
4178            '>'
4179
4180    def to_dict(self):
4181        return {
4182            'bind_interface': self.bind_interface,
4183            'database': self.database,
4184            'egress_filter': self.egress_filter,
4185            'healthy': self.healthy,
4186            'hostname': self.hostname,
4187            'id': self.id,
4188            'name': self.name,
4189            'password': self.password,
4190            'port': self.port,
4191            'port_override': self.port_override,
4192            'secret_store_id': self.secret_store_id,
4193            'tags': self.tags,
4194            'username': self.username,
4195        }
4196
4197    @classmethod
4198    def from_dict(cls, d):
4199        return cls(
4200            bind_interface=d.get('bind_interface'),
4201            database=d.get('database'),
4202            egress_filter=d.get('egress_filter'),
4203            healthy=d.get('healthy'),
4204            hostname=d.get('hostname'),
4205            id=d.get('id'),
4206            name=d.get('name'),
4207            password=d.get('password'),
4208            port=d.get('port'),
4209            port_override=d.get('port_override'),
4210            secret_store_id=d.get('secret_store_id'),
4211            tags=d.get('tags'),
4212            username=d.get('username'),
4213        )
DB2LUW( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
4094    def __init__(
4095        self,
4096        bind_interface=None,
4097        database=None,
4098        egress_filter=None,
4099        healthy=None,
4100        hostname=None,
4101        id=None,
4102        name=None,
4103        password=None,
4104        port=None,
4105        port_override=None,
4106        secret_store_id=None,
4107        tags=None,
4108        username=None,
4109    ):
4110        self.bind_interface = bind_interface if bind_interface is not None else ''
4111        '''
4112         Bind interface
4113        '''
4114        self.database = database if database is not None else ''
4115        '''
4116
4117        '''
4118        self.egress_filter = egress_filter if egress_filter is not None else ''
4119        '''
4120         A filter applied to the routing logic to pin datasource to nodes.
4121        '''
4122        self.healthy = healthy if healthy is not None else False
4123        '''
4124         True if the datasource is reachable and the credentials are valid.
4125        '''
4126        self.hostname = hostname if hostname is not None else ''
4127        '''
4128
4129        '''
4130        self.id = id if id is not None else ''
4131        '''
4132         Unique identifier of the Resource.
4133        '''
4134        self.name = name if name is not None else ''
4135        '''
4136         Unique human-readable name of the Resource.
4137        '''
4138        self.password = password if password is not None else ''
4139        '''
4140
4141        '''
4142        self.port = port if port is not None else 0
4143        '''
4144
4145        '''
4146        self.port_override = port_override if port_override is not None else 0
4147        '''
4148
4149        '''
4150        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4151        '''
4152         ID of the secret store containing credentials for this resource, if any.
4153        '''
4154        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4155        '''
4156         Tags is a map of key, value pairs.
4157        '''
4158        self.username = username if username is not None else ''
4159        '''
4160
4161        '''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
4180    def to_dict(self):
4181        return {
4182            'bind_interface': self.bind_interface,
4183            'database': self.database,
4184            'egress_filter': self.egress_filter,
4185            'healthy': self.healthy,
4186            'hostname': self.hostname,
4187            'id': self.id,
4188            'name': self.name,
4189            'password': self.password,
4190            'port': self.port,
4191            'port_override': self.port_override,
4192            'secret_store_id': self.secret_store_id,
4193            'tags': self.tags,
4194            'username': self.username,
4195        }
@classmethod
def from_dict(cls, d)
4197    @classmethod
4198    def from_dict(cls, d):
4199        return cls(
4200            bind_interface=d.get('bind_interface'),
4201            database=d.get('database'),
4202            egress_filter=d.get('egress_filter'),
4203            healthy=d.get('healthy'),
4204            hostname=d.get('hostname'),
4205            id=d.get('id'),
4206            name=d.get('name'),
4207            password=d.get('password'),
4208            port=d.get('port'),
4209            port_override=d.get('port_override'),
4210            secret_store_id=d.get('secret_store_id'),
4211            tags=d.get('tags'),
4212            username=d.get('username'),
4213        )
class DeleteResponseMetadata:
4216class DeleteResponseMetadata:
4217    '''
4218     DeleteResponseMetadata is reserved for future use.
4219    '''
4220    __slots__ = []
4221
4222    def __init__(self, ):
4223        pass
4224
4225    def __repr__(self):
4226        return '<sdm.DeleteResponseMetadata ' + \
4227            '>'
4228
4229    def to_dict(self):
4230        return {}
4231
4232    @classmethod
4233    def from_dict(cls, d):
4234        return cls()

DeleteResponseMetadata is reserved for future use.

DeleteResponseMetadata()
4222    def __init__(self, ):
4223        pass
def to_dict(self)
4229    def to_dict(self):
4230        return {}
@classmethod
def from_dict(cls, d)
4232    @classmethod
4233    def from_dict(cls, d):
4234        return cls()
class DocumentDBHost:
4237class DocumentDBHost:
4238    '''
4239
4240    '''
4241    __slots__ = [
4242        'auth_database',
4243        'bind_interface',
4244        'egress_filter',
4245        'healthy',
4246        'hostname',
4247        'id',
4248        'name',
4249        'password',
4250        'port',
4251        'port_override',
4252        'secret_store_id',
4253        'tags',
4254        'username',
4255    ]
4256
4257    def __init__(
4258        self,
4259        auth_database=None,
4260        bind_interface=None,
4261        egress_filter=None,
4262        healthy=None,
4263        hostname=None,
4264        id=None,
4265        name=None,
4266        password=None,
4267        port=None,
4268        port_override=None,
4269        secret_store_id=None,
4270        tags=None,
4271        username=None,
4272    ):
4273        self.auth_database = auth_database if auth_database is not None else ''
4274        '''
4275
4276        '''
4277        self.bind_interface = bind_interface if bind_interface is not None else ''
4278        '''
4279         Bind interface
4280        '''
4281        self.egress_filter = egress_filter if egress_filter is not None else ''
4282        '''
4283         A filter applied to the routing logic to pin datasource to nodes.
4284        '''
4285        self.healthy = healthy if healthy is not None else False
4286        '''
4287         True if the datasource is reachable and the credentials are valid.
4288        '''
4289        self.hostname = hostname if hostname is not None else ''
4290        '''
4291
4292        '''
4293        self.id = id if id is not None else ''
4294        '''
4295         Unique identifier of the Resource.
4296        '''
4297        self.name = name if name is not None else ''
4298        '''
4299         Unique human-readable name of the Resource.
4300        '''
4301        self.password = password if password is not None else ''
4302        '''
4303
4304        '''
4305        self.port = port if port is not None else 0
4306        '''
4307
4308        '''
4309        self.port_override = port_override if port_override is not None else 0
4310        '''
4311
4312        '''
4313        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4314        '''
4315         ID of the secret store containing credentials for this resource, if any.
4316        '''
4317        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4318        '''
4319         Tags is a map of key, value pairs.
4320        '''
4321        self.username = username if username is not None else ''
4322        '''
4323
4324        '''
4325
4326    def __repr__(self):
4327        return '<sdm.DocumentDBHost ' + \
4328            'auth_database: ' + repr(self.auth_database) + ' ' +\
4329            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
4330            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
4331            'healthy: ' + repr(self.healthy) + ' ' +\
4332            'hostname: ' + repr(self.hostname) + ' ' +\
4333            'id: ' + repr(self.id) + ' ' +\
4334            'name: ' + repr(self.name) + ' ' +\
4335            'password: ' + repr(self.password) + ' ' +\
4336            'port: ' + repr(self.port) + ' ' +\
4337            'port_override: ' + repr(self.port_override) + ' ' +\
4338            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
4339            'tags: ' + repr(self.tags) + ' ' +\
4340            'username: ' + repr(self.username) + ' ' +\
4341            '>'
4342
4343    def to_dict(self):
4344        return {
4345            'auth_database': self.auth_database,
4346            'bind_interface': self.bind_interface,
4347            'egress_filter': self.egress_filter,
4348            'healthy': self.healthy,
4349            'hostname': self.hostname,
4350            'id': self.id,
4351            'name': self.name,
4352            'password': self.password,
4353            'port': self.port,
4354            'port_override': self.port_override,
4355            'secret_store_id': self.secret_store_id,
4356            'tags': self.tags,
4357            'username': self.username,
4358        }
4359
4360    @classmethod
4361    def from_dict(cls, d):
4362        return cls(
4363            auth_database=d.get('auth_database'),
4364            bind_interface=d.get('bind_interface'),
4365            egress_filter=d.get('egress_filter'),
4366            healthy=d.get('healthy'),
4367            hostname=d.get('hostname'),
4368            id=d.get('id'),
4369            name=d.get('name'),
4370            password=d.get('password'),
4371            port=d.get('port'),
4372            port_override=d.get('port_override'),
4373            secret_store_id=d.get('secret_store_id'),
4374            tags=d.get('tags'),
4375            username=d.get('username'),
4376        )
DocumentDBHost( auth_database=None, bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
4257    def __init__(
4258        self,
4259        auth_database=None,
4260        bind_interface=None,
4261        egress_filter=None,
4262        healthy=None,
4263        hostname=None,
4264        id=None,
4265        name=None,
4266        password=None,
4267        port=None,
4268        port_override=None,
4269        secret_store_id=None,
4270        tags=None,
4271        username=None,
4272    ):
4273        self.auth_database = auth_database if auth_database is not None else ''
4274        '''
4275
4276        '''
4277        self.bind_interface = bind_interface if bind_interface is not None else ''
4278        '''
4279         Bind interface
4280        '''
4281        self.egress_filter = egress_filter if egress_filter is not None else ''
4282        '''
4283         A filter applied to the routing logic to pin datasource to nodes.
4284        '''
4285        self.healthy = healthy if healthy is not None else False
4286        '''
4287         True if the datasource is reachable and the credentials are valid.
4288        '''
4289        self.hostname = hostname if hostname is not None else ''
4290        '''
4291
4292        '''
4293        self.id = id if id is not None else ''
4294        '''
4295         Unique identifier of the Resource.
4296        '''
4297        self.name = name if name is not None else ''
4298        '''
4299         Unique human-readable name of the Resource.
4300        '''
4301        self.password = password if password is not None else ''
4302        '''
4303
4304        '''
4305        self.port = port if port is not None else 0
4306        '''
4307
4308        '''
4309        self.port_override = port_override if port_override is not None else 0
4310        '''
4311
4312        '''
4313        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4314        '''
4315         ID of the secret store containing credentials for this resource, if any.
4316        '''
4317        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4318        '''
4319         Tags is a map of key, value pairs.
4320        '''
4321        self.username = username if username is not None else ''
4322        '''
4323
4324        '''
auth_database
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
4343    def to_dict(self):
4344        return {
4345            'auth_database': self.auth_database,
4346            'bind_interface': self.bind_interface,
4347            'egress_filter': self.egress_filter,
4348            'healthy': self.healthy,
4349            'hostname': self.hostname,
4350            'id': self.id,
4351            'name': self.name,
4352            'password': self.password,
4353            'port': self.port,
4354            'port_override': self.port_override,
4355            'secret_store_id': self.secret_store_id,
4356            'tags': self.tags,
4357            'username': self.username,
4358        }
@classmethod
def from_dict(cls, d)
4360    @classmethod
4361    def from_dict(cls, d):
4362        return cls(
4363            auth_database=d.get('auth_database'),
4364            bind_interface=d.get('bind_interface'),
4365            egress_filter=d.get('egress_filter'),
4366            healthy=d.get('healthy'),
4367            hostname=d.get('hostname'),
4368            id=d.get('id'),
4369            name=d.get('name'),
4370            password=d.get('password'),
4371            port=d.get('port'),
4372            port_override=d.get('port_override'),
4373            secret_store_id=d.get('secret_store_id'),
4374            tags=d.get('tags'),
4375            username=d.get('username'),
4376        )
class DocumentDBReplicaSet:
4379class DocumentDBReplicaSet:
4380    '''
4381
4382    '''
4383    __slots__ = [
4384        'auth_database',
4385        'bind_interface',
4386        'connect_to_replica',
4387        'egress_filter',
4388        'healthy',
4389        'hostname',
4390        'id',
4391        'name',
4392        'password',
4393        'port_override',
4394        'replica_set',
4395        'secret_store_id',
4396        'tags',
4397        'username',
4398    ]
4399
4400    def __init__(
4401        self,
4402        auth_database=None,
4403        bind_interface=None,
4404        connect_to_replica=None,
4405        egress_filter=None,
4406        healthy=None,
4407        hostname=None,
4408        id=None,
4409        name=None,
4410        password=None,
4411        port_override=None,
4412        replica_set=None,
4413        secret_store_id=None,
4414        tags=None,
4415        username=None,
4416    ):
4417        self.auth_database = auth_database if auth_database is not None else ''
4418        '''
4419
4420        '''
4421        self.bind_interface = bind_interface if bind_interface is not None else ''
4422        '''
4423         Bind interface
4424        '''
4425        self.connect_to_replica = connect_to_replica if connect_to_replica is not None else False
4426        '''
4427
4428        '''
4429        self.egress_filter = egress_filter if egress_filter is not None else ''
4430        '''
4431         A filter applied to the routing logic to pin datasource to nodes.
4432        '''
4433        self.healthy = healthy if healthy is not None else False
4434        '''
4435         True if the datasource is reachable and the credentials are valid.
4436        '''
4437        self.hostname = hostname if hostname is not None else ''
4438        '''
4439         Hostname must contain the hostname/port pairs of all instances in the replica set separated by commas.
4440        '''
4441        self.id = id if id is not None else ''
4442        '''
4443         Unique identifier of the Resource.
4444        '''
4445        self.name = name if name is not None else ''
4446        '''
4447         Unique human-readable name of the Resource.
4448        '''
4449        self.password = password if password is not None else ''
4450        '''
4451
4452        '''
4453        self.port_override = port_override if port_override is not None else 0
4454        '''
4455
4456        '''
4457        self.replica_set = replica_set if replica_set is not None else ''
4458        '''
4459
4460        '''
4461        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4462        '''
4463         ID of the secret store containing credentials for this resource, if any.
4464        '''
4465        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4466        '''
4467         Tags is a map of key, value pairs.
4468        '''
4469        self.username = username if username is not None else ''
4470        '''
4471
4472        '''
4473
4474    def __repr__(self):
4475        return '<sdm.DocumentDBReplicaSet ' + \
4476            'auth_database: ' + repr(self.auth_database) + ' ' +\
4477            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
4478            'connect_to_replica: ' + repr(self.connect_to_replica) + ' ' +\
4479            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
4480            'healthy: ' + repr(self.healthy) + ' ' +\
4481            'hostname: ' + repr(self.hostname) + ' ' +\
4482            'id: ' + repr(self.id) + ' ' +\
4483            'name: ' + repr(self.name) + ' ' +\
4484            'password: ' + repr(self.password) + ' ' +\
4485            'port_override: ' + repr(self.port_override) + ' ' +\
4486            'replica_set: ' + repr(self.replica_set) + ' ' +\
4487            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
4488            'tags: ' + repr(self.tags) + ' ' +\
4489            'username: ' + repr(self.username) + ' ' +\
4490            '>'
4491
4492    def to_dict(self):
4493        return {
4494            'auth_database': self.auth_database,
4495            'bind_interface': self.bind_interface,
4496            'connect_to_replica': self.connect_to_replica,
4497            'egress_filter': self.egress_filter,
4498            'healthy': self.healthy,
4499            'hostname': self.hostname,
4500            'id': self.id,
4501            'name': self.name,
4502            'password': self.password,
4503            'port_override': self.port_override,
4504            'replica_set': self.replica_set,
4505            'secret_store_id': self.secret_store_id,
4506            'tags': self.tags,
4507            'username': self.username,
4508        }
4509
4510    @classmethod
4511    def from_dict(cls, d):
4512        return cls(
4513            auth_database=d.get('auth_database'),
4514            bind_interface=d.get('bind_interface'),
4515            connect_to_replica=d.get('connect_to_replica'),
4516            egress_filter=d.get('egress_filter'),
4517            healthy=d.get('healthy'),
4518            hostname=d.get('hostname'),
4519            id=d.get('id'),
4520            name=d.get('name'),
4521            password=d.get('password'),
4522            port_override=d.get('port_override'),
4523            replica_set=d.get('replica_set'),
4524            secret_store_id=d.get('secret_store_id'),
4525            tags=d.get('tags'),
4526            username=d.get('username'),
4527        )
DocumentDBReplicaSet( auth_database=None, bind_interface=None, connect_to_replica=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port_override=None, replica_set=None, secret_store_id=None, tags=None, username=None)
4400    def __init__(
4401        self,
4402        auth_database=None,
4403        bind_interface=None,
4404        connect_to_replica=None,
4405        egress_filter=None,
4406        healthy=None,
4407        hostname=None,
4408        id=None,
4409        name=None,
4410        password=None,
4411        port_override=None,
4412        replica_set=None,
4413        secret_store_id=None,
4414        tags=None,
4415        username=None,
4416    ):
4417        self.auth_database = auth_database if auth_database is not None else ''
4418        '''
4419
4420        '''
4421        self.bind_interface = bind_interface if bind_interface is not None else ''
4422        '''
4423         Bind interface
4424        '''
4425        self.connect_to_replica = connect_to_replica if connect_to_replica is not None else False
4426        '''
4427
4428        '''
4429        self.egress_filter = egress_filter if egress_filter is not None else ''
4430        '''
4431         A filter applied to the routing logic to pin datasource to nodes.
4432        '''
4433        self.healthy = healthy if healthy is not None else False
4434        '''
4435         True if the datasource is reachable and the credentials are valid.
4436        '''
4437        self.hostname = hostname if hostname is not None else ''
4438        '''
4439         Hostname must contain the hostname/port pairs of all instances in the replica set separated by commas.
4440        '''
4441        self.id = id if id is not None else ''
4442        '''
4443         Unique identifier of the Resource.
4444        '''
4445        self.name = name if name is not None else ''
4446        '''
4447         Unique human-readable name of the Resource.
4448        '''
4449        self.password = password if password is not None else ''
4450        '''
4451
4452        '''
4453        self.port_override = port_override if port_override is not None else 0
4454        '''
4455
4456        '''
4457        self.replica_set = replica_set if replica_set is not None else ''
4458        '''
4459
4460        '''
4461        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4462        '''
4463         ID of the secret store containing credentials for this resource, if any.
4464        '''
4465        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4466        '''
4467         Tags is a map of key, value pairs.
4468        '''
4469        self.username = username if username is not None else ''
4470        '''
4471
4472        '''
auth_database
bind_interface

Bind interface

connect_to_replica
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname

Hostname must contain the hostname/port pairs of all instances in the replica set separated by commas.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port_override
replica_set
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
4492    def to_dict(self):
4493        return {
4494            'auth_database': self.auth_database,
4495            'bind_interface': self.bind_interface,
4496            'connect_to_replica': self.connect_to_replica,
4497            'egress_filter': self.egress_filter,
4498            'healthy': self.healthy,
4499            'hostname': self.hostname,
4500            'id': self.id,
4501            'name': self.name,
4502            'password': self.password,
4503            'port_override': self.port_override,
4504            'replica_set': self.replica_set,
4505            'secret_store_id': self.secret_store_id,
4506            'tags': self.tags,
4507            'username': self.username,
4508        }
@classmethod
def from_dict(cls, d)
4510    @classmethod
4511    def from_dict(cls, d):
4512        return cls(
4513            auth_database=d.get('auth_database'),
4514            bind_interface=d.get('bind_interface'),
4515            connect_to_replica=d.get('connect_to_replica'),
4516            egress_filter=d.get('egress_filter'),
4517            healthy=d.get('healthy'),
4518            hostname=d.get('hostname'),
4519            id=d.get('id'),
4520            name=d.get('name'),
4521            password=d.get('password'),
4522            port_override=d.get('port_override'),
4523            replica_set=d.get('replica_set'),
4524            secret_store_id=d.get('secret_store_id'),
4525            tags=d.get('tags'),
4526            username=d.get('username'),
4527        )
class Druid:
4530class Druid:
4531    '''
4532
4533    '''
4534    __slots__ = [
4535        'bind_interface',
4536        'egress_filter',
4537        'healthy',
4538        'hostname',
4539        'id',
4540        'name',
4541        'password',
4542        'port',
4543        'port_override',
4544        'secret_store_id',
4545        'tags',
4546        'username',
4547    ]
4548
4549    def __init__(
4550        self,
4551        bind_interface=None,
4552        egress_filter=None,
4553        healthy=None,
4554        hostname=None,
4555        id=None,
4556        name=None,
4557        password=None,
4558        port=None,
4559        port_override=None,
4560        secret_store_id=None,
4561        tags=None,
4562        username=None,
4563    ):
4564        self.bind_interface = bind_interface if bind_interface is not None else ''
4565        '''
4566         Bind interface
4567        '''
4568        self.egress_filter = egress_filter if egress_filter is not None else ''
4569        '''
4570         A filter applied to the routing logic to pin datasource to nodes.
4571        '''
4572        self.healthy = healthy if healthy is not None else False
4573        '''
4574         True if the datasource is reachable and the credentials are valid.
4575        '''
4576        self.hostname = hostname if hostname is not None else ''
4577        '''
4578
4579        '''
4580        self.id = id if id is not None else ''
4581        '''
4582         Unique identifier of the Resource.
4583        '''
4584        self.name = name if name is not None else ''
4585        '''
4586         Unique human-readable name of the Resource.
4587        '''
4588        self.password = password if password is not None else ''
4589        '''
4590
4591        '''
4592        self.port = port if port is not None else 0
4593        '''
4594
4595        '''
4596        self.port_override = port_override if port_override is not None else 0
4597        '''
4598
4599        '''
4600        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4601        '''
4602         ID of the secret store containing credentials for this resource, if any.
4603        '''
4604        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4605        '''
4606         Tags is a map of key, value pairs.
4607        '''
4608        self.username = username if username is not None else ''
4609        '''
4610
4611        '''
4612
4613    def __repr__(self):
4614        return '<sdm.Druid ' + \
4615            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
4616            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
4617            'healthy: ' + repr(self.healthy) + ' ' +\
4618            'hostname: ' + repr(self.hostname) + ' ' +\
4619            'id: ' + repr(self.id) + ' ' +\
4620            'name: ' + repr(self.name) + ' ' +\
4621            'password: ' + repr(self.password) + ' ' +\
4622            'port: ' + repr(self.port) + ' ' +\
4623            'port_override: ' + repr(self.port_override) + ' ' +\
4624            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
4625            'tags: ' + repr(self.tags) + ' ' +\
4626            'username: ' + repr(self.username) + ' ' +\
4627            '>'
4628
4629    def to_dict(self):
4630        return {
4631            'bind_interface': self.bind_interface,
4632            'egress_filter': self.egress_filter,
4633            'healthy': self.healthy,
4634            'hostname': self.hostname,
4635            'id': self.id,
4636            'name': self.name,
4637            'password': self.password,
4638            'port': self.port,
4639            'port_override': self.port_override,
4640            'secret_store_id': self.secret_store_id,
4641            'tags': self.tags,
4642            'username': self.username,
4643        }
4644
4645    @classmethod
4646    def from_dict(cls, d):
4647        return cls(
4648            bind_interface=d.get('bind_interface'),
4649            egress_filter=d.get('egress_filter'),
4650            healthy=d.get('healthy'),
4651            hostname=d.get('hostname'),
4652            id=d.get('id'),
4653            name=d.get('name'),
4654            password=d.get('password'),
4655            port=d.get('port'),
4656            port_override=d.get('port_override'),
4657            secret_store_id=d.get('secret_store_id'),
4658            tags=d.get('tags'),
4659            username=d.get('username'),
4660        )
Druid( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
4549    def __init__(
4550        self,
4551        bind_interface=None,
4552        egress_filter=None,
4553        healthy=None,
4554        hostname=None,
4555        id=None,
4556        name=None,
4557        password=None,
4558        port=None,
4559        port_override=None,
4560        secret_store_id=None,
4561        tags=None,
4562        username=None,
4563    ):
4564        self.bind_interface = bind_interface if bind_interface is not None else ''
4565        '''
4566         Bind interface
4567        '''
4568        self.egress_filter = egress_filter if egress_filter is not None else ''
4569        '''
4570         A filter applied to the routing logic to pin datasource to nodes.
4571        '''
4572        self.healthy = healthy if healthy is not None else False
4573        '''
4574         True if the datasource is reachable and the credentials are valid.
4575        '''
4576        self.hostname = hostname if hostname is not None else ''
4577        '''
4578
4579        '''
4580        self.id = id if id is not None else ''
4581        '''
4582         Unique identifier of the Resource.
4583        '''
4584        self.name = name if name is not None else ''
4585        '''
4586         Unique human-readable name of the Resource.
4587        '''
4588        self.password = password if password is not None else ''
4589        '''
4590
4591        '''
4592        self.port = port if port is not None else 0
4593        '''
4594
4595        '''
4596        self.port_override = port_override if port_override is not None else 0
4597        '''
4598
4599        '''
4600        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4601        '''
4602         ID of the secret store containing credentials for this resource, if any.
4603        '''
4604        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4605        '''
4606         Tags is a map of key, value pairs.
4607        '''
4608        self.username = username if username is not None else ''
4609        '''
4610
4611        '''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
4629    def to_dict(self):
4630        return {
4631            'bind_interface': self.bind_interface,
4632            'egress_filter': self.egress_filter,
4633            'healthy': self.healthy,
4634            'hostname': self.hostname,
4635            'id': self.id,
4636            'name': self.name,
4637            'password': self.password,
4638            'port': self.port,
4639            'port_override': self.port_override,
4640            'secret_store_id': self.secret_store_id,
4641            'tags': self.tags,
4642            'username': self.username,
4643        }
@classmethod
def from_dict(cls, d)
4645    @classmethod
4646    def from_dict(cls, d):
4647        return cls(
4648            bind_interface=d.get('bind_interface'),
4649            egress_filter=d.get('egress_filter'),
4650            healthy=d.get('healthy'),
4651            hostname=d.get('hostname'),
4652            id=d.get('id'),
4653            name=d.get('name'),
4654            password=d.get('password'),
4655            port=d.get('port'),
4656            port_override=d.get('port_override'),
4657            secret_store_id=d.get('secret_store_id'),
4658            tags=d.get('tags'),
4659            username=d.get('username'),
4660        )
class DynamoDB:
4663class DynamoDB:
4664    '''
4665
4666    '''
4667    __slots__ = [
4668        'access_key',
4669        'bind_interface',
4670        'egress_filter',
4671        'endpoint',
4672        'healthy',
4673        'id',
4674        'name',
4675        'port_override',
4676        'region',
4677        'role_arn',
4678        'role_external_id',
4679        'secret_access_key',
4680        'secret_store_id',
4681        'tags',
4682    ]
4683
4684    def __init__(
4685        self,
4686        access_key=None,
4687        bind_interface=None,
4688        egress_filter=None,
4689        endpoint=None,
4690        healthy=None,
4691        id=None,
4692        name=None,
4693        port_override=None,
4694        region=None,
4695        role_arn=None,
4696        role_external_id=None,
4697        secret_access_key=None,
4698        secret_store_id=None,
4699        tags=None,
4700    ):
4701        self.access_key = access_key if access_key is not None else ''
4702        '''
4703
4704        '''
4705        self.bind_interface = bind_interface if bind_interface is not None else ''
4706        '''
4707         Bind interface
4708        '''
4709        self.egress_filter = egress_filter if egress_filter is not None else ''
4710        '''
4711         A filter applied to the routing logic to pin datasource to nodes.
4712        '''
4713        self.endpoint = endpoint if endpoint is not None else ''
4714        '''
4715
4716        '''
4717        self.healthy = healthy if healthy is not None else False
4718        '''
4719         True if the datasource is reachable and the credentials are valid.
4720        '''
4721        self.id = id if id is not None else ''
4722        '''
4723         Unique identifier of the Resource.
4724        '''
4725        self.name = name if name is not None else ''
4726        '''
4727         Unique human-readable name of the Resource.
4728        '''
4729        self.port_override = port_override if port_override is not None else 0
4730        '''
4731
4732        '''
4733        self.region = region if region is not None else ''
4734        '''
4735
4736        '''
4737        self.role_arn = role_arn if role_arn is not None else ''
4738        '''
4739
4740        '''
4741        self.role_external_id = role_external_id if role_external_id is not None else ''
4742        '''
4743
4744        '''
4745        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
4746        '''
4747
4748        '''
4749        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4750        '''
4751         ID of the secret store containing credentials for this resource, if any.
4752        '''
4753        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4754        '''
4755         Tags is a map of key, value pairs.
4756        '''
4757
4758    def __repr__(self):
4759        return '<sdm.DynamoDB ' + \
4760            'access_key: ' + repr(self.access_key) + ' ' +\
4761            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
4762            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
4763            'endpoint: ' + repr(self.endpoint) + ' ' +\
4764            'healthy: ' + repr(self.healthy) + ' ' +\
4765            'id: ' + repr(self.id) + ' ' +\
4766            'name: ' + repr(self.name) + ' ' +\
4767            'port_override: ' + repr(self.port_override) + ' ' +\
4768            'region: ' + repr(self.region) + ' ' +\
4769            'role_arn: ' + repr(self.role_arn) + ' ' +\
4770            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
4771            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
4772            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
4773            'tags: ' + repr(self.tags) + ' ' +\
4774            '>'
4775
4776    def to_dict(self):
4777        return {
4778            'access_key': self.access_key,
4779            'bind_interface': self.bind_interface,
4780            'egress_filter': self.egress_filter,
4781            'endpoint': self.endpoint,
4782            'healthy': self.healthy,
4783            'id': self.id,
4784            'name': self.name,
4785            'port_override': self.port_override,
4786            'region': self.region,
4787            'role_arn': self.role_arn,
4788            'role_external_id': self.role_external_id,
4789            'secret_access_key': self.secret_access_key,
4790            'secret_store_id': self.secret_store_id,
4791            'tags': self.tags,
4792        }
4793
4794    @classmethod
4795    def from_dict(cls, d):
4796        return cls(
4797            access_key=d.get('access_key'),
4798            bind_interface=d.get('bind_interface'),
4799            egress_filter=d.get('egress_filter'),
4800            endpoint=d.get('endpoint'),
4801            healthy=d.get('healthy'),
4802            id=d.get('id'),
4803            name=d.get('name'),
4804            port_override=d.get('port_override'),
4805            region=d.get('region'),
4806            role_arn=d.get('role_arn'),
4807            role_external_id=d.get('role_external_id'),
4808            secret_access_key=d.get('secret_access_key'),
4809            secret_store_id=d.get('secret_store_id'),
4810            tags=d.get('tags'),
4811        )
DynamoDB( access_key=None, bind_interface=None, egress_filter=None, endpoint=None, healthy=None, id=None, name=None, port_override=None, region=None, role_arn=None, role_external_id=None, secret_access_key=None, secret_store_id=None, tags=None)
4684    def __init__(
4685        self,
4686        access_key=None,
4687        bind_interface=None,
4688        egress_filter=None,
4689        endpoint=None,
4690        healthy=None,
4691        id=None,
4692        name=None,
4693        port_override=None,
4694        region=None,
4695        role_arn=None,
4696        role_external_id=None,
4697        secret_access_key=None,
4698        secret_store_id=None,
4699        tags=None,
4700    ):
4701        self.access_key = access_key if access_key is not None else ''
4702        '''
4703
4704        '''
4705        self.bind_interface = bind_interface if bind_interface is not None else ''
4706        '''
4707         Bind interface
4708        '''
4709        self.egress_filter = egress_filter if egress_filter is not None else ''
4710        '''
4711         A filter applied to the routing logic to pin datasource to nodes.
4712        '''
4713        self.endpoint = endpoint if endpoint is not None else ''
4714        '''
4715
4716        '''
4717        self.healthy = healthy if healthy is not None else False
4718        '''
4719         True if the datasource is reachable and the credentials are valid.
4720        '''
4721        self.id = id if id is not None else ''
4722        '''
4723         Unique identifier of the Resource.
4724        '''
4725        self.name = name if name is not None else ''
4726        '''
4727         Unique human-readable name of the Resource.
4728        '''
4729        self.port_override = port_override if port_override is not None else 0
4730        '''
4731
4732        '''
4733        self.region = region if region is not None else ''
4734        '''
4735
4736        '''
4737        self.role_arn = role_arn if role_arn is not None else ''
4738        '''
4739
4740        '''
4741        self.role_external_id = role_external_id if role_external_id is not None else ''
4742        '''
4743
4744        '''
4745        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
4746        '''
4747
4748        '''
4749        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4750        '''
4751         ID of the secret store containing credentials for this resource, if any.
4752        '''
4753        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4754        '''
4755         Tags is a map of key, value pairs.
4756        '''
access_key
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

endpoint
healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port_override
region
role_arn
role_external_id
secret_access_key
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
4776    def to_dict(self):
4777        return {
4778            'access_key': self.access_key,
4779            'bind_interface': self.bind_interface,
4780            'egress_filter': self.egress_filter,
4781            'endpoint': self.endpoint,
4782            'healthy': self.healthy,
4783            'id': self.id,
4784            'name': self.name,
4785            'port_override': self.port_override,
4786            'region': self.region,
4787            'role_arn': self.role_arn,
4788            'role_external_id': self.role_external_id,
4789            'secret_access_key': self.secret_access_key,
4790            'secret_store_id': self.secret_store_id,
4791            'tags': self.tags,
4792        }
@classmethod
def from_dict(cls, d)
4794    @classmethod
4795    def from_dict(cls, d):
4796        return cls(
4797            access_key=d.get('access_key'),
4798            bind_interface=d.get('bind_interface'),
4799            egress_filter=d.get('egress_filter'),
4800            endpoint=d.get('endpoint'),
4801            healthy=d.get('healthy'),
4802            id=d.get('id'),
4803            name=d.get('name'),
4804            port_override=d.get('port_override'),
4805            region=d.get('region'),
4806            role_arn=d.get('role_arn'),
4807            role_external_id=d.get('role_external_id'),
4808            secret_access_key=d.get('secret_access_key'),
4809            secret_store_id=d.get('secret_store_id'),
4810            tags=d.get('tags'),
4811        )
class Elastic:
4814class Elastic:
4815    '''
4816
4817    '''
4818    __slots__ = [
4819        'bind_interface',
4820        'egress_filter',
4821        'healthy',
4822        'hostname',
4823        'id',
4824        'name',
4825        'password',
4826        'port',
4827        'port_override',
4828        'secret_store_id',
4829        'tags',
4830        'tls_required',
4831        'username',
4832    ]
4833
4834    def __init__(
4835        self,
4836        bind_interface=None,
4837        egress_filter=None,
4838        healthy=None,
4839        hostname=None,
4840        id=None,
4841        name=None,
4842        password=None,
4843        port=None,
4844        port_override=None,
4845        secret_store_id=None,
4846        tags=None,
4847        tls_required=None,
4848        username=None,
4849    ):
4850        self.bind_interface = bind_interface if bind_interface is not None else ''
4851        '''
4852         Bind interface
4853        '''
4854        self.egress_filter = egress_filter if egress_filter is not None else ''
4855        '''
4856         A filter applied to the routing logic to pin datasource to nodes.
4857        '''
4858        self.healthy = healthy if healthy is not None else False
4859        '''
4860         True if the datasource is reachable and the credentials are valid.
4861        '''
4862        self.hostname = hostname if hostname is not None else ''
4863        '''
4864
4865        '''
4866        self.id = id if id is not None else ''
4867        '''
4868         Unique identifier of the Resource.
4869        '''
4870        self.name = name if name is not None else ''
4871        '''
4872         Unique human-readable name of the Resource.
4873        '''
4874        self.password = password if password is not None else ''
4875        '''
4876
4877        '''
4878        self.port = port if port is not None else 0
4879        '''
4880
4881        '''
4882        self.port_override = port_override if port_override is not None else 0
4883        '''
4884
4885        '''
4886        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4887        '''
4888         ID of the secret store containing credentials for this resource, if any.
4889        '''
4890        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4891        '''
4892         Tags is a map of key, value pairs.
4893        '''
4894        self.tls_required = tls_required if tls_required is not None else False
4895        '''
4896
4897        '''
4898        self.username = username if username is not None else ''
4899        '''
4900
4901        '''
4902
4903    def __repr__(self):
4904        return '<sdm.Elastic ' + \
4905            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
4906            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
4907            'healthy: ' + repr(self.healthy) + ' ' +\
4908            'hostname: ' + repr(self.hostname) + ' ' +\
4909            'id: ' + repr(self.id) + ' ' +\
4910            'name: ' + repr(self.name) + ' ' +\
4911            'password: ' + repr(self.password) + ' ' +\
4912            'port: ' + repr(self.port) + ' ' +\
4913            'port_override: ' + repr(self.port_override) + ' ' +\
4914            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
4915            'tags: ' + repr(self.tags) + ' ' +\
4916            'tls_required: ' + repr(self.tls_required) + ' ' +\
4917            'username: ' + repr(self.username) + ' ' +\
4918            '>'
4919
4920    def to_dict(self):
4921        return {
4922            'bind_interface': self.bind_interface,
4923            'egress_filter': self.egress_filter,
4924            'healthy': self.healthy,
4925            'hostname': self.hostname,
4926            'id': self.id,
4927            'name': self.name,
4928            'password': self.password,
4929            'port': self.port,
4930            'port_override': self.port_override,
4931            'secret_store_id': self.secret_store_id,
4932            'tags': self.tags,
4933            'tls_required': self.tls_required,
4934            'username': self.username,
4935        }
4936
4937    @classmethod
4938    def from_dict(cls, d):
4939        return cls(
4940            bind_interface=d.get('bind_interface'),
4941            egress_filter=d.get('egress_filter'),
4942            healthy=d.get('healthy'),
4943            hostname=d.get('hostname'),
4944            id=d.get('id'),
4945            name=d.get('name'),
4946            password=d.get('password'),
4947            port=d.get('port'),
4948            port_override=d.get('port_override'),
4949            secret_store_id=d.get('secret_store_id'),
4950            tags=d.get('tags'),
4951            tls_required=d.get('tls_required'),
4952            username=d.get('username'),
4953        )
Elastic( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, tls_required=None, username=None)
4834    def __init__(
4835        self,
4836        bind_interface=None,
4837        egress_filter=None,
4838        healthy=None,
4839        hostname=None,
4840        id=None,
4841        name=None,
4842        password=None,
4843        port=None,
4844        port_override=None,
4845        secret_store_id=None,
4846        tags=None,
4847        tls_required=None,
4848        username=None,
4849    ):
4850        self.bind_interface = bind_interface if bind_interface is not None else ''
4851        '''
4852         Bind interface
4853        '''
4854        self.egress_filter = egress_filter if egress_filter is not None else ''
4855        '''
4856         A filter applied to the routing logic to pin datasource to nodes.
4857        '''
4858        self.healthy = healthy if healthy is not None else False
4859        '''
4860         True if the datasource is reachable and the credentials are valid.
4861        '''
4862        self.hostname = hostname if hostname is not None else ''
4863        '''
4864
4865        '''
4866        self.id = id if id is not None else ''
4867        '''
4868         Unique identifier of the Resource.
4869        '''
4870        self.name = name if name is not None else ''
4871        '''
4872         Unique human-readable name of the Resource.
4873        '''
4874        self.password = password if password is not None else ''
4875        '''
4876
4877        '''
4878        self.port = port if port is not None else 0
4879        '''
4880
4881        '''
4882        self.port_override = port_override if port_override is not None else 0
4883        '''
4884
4885        '''
4886        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
4887        '''
4888         ID of the secret store containing credentials for this resource, if any.
4889        '''
4890        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
4891        '''
4892         Tags is a map of key, value pairs.
4893        '''
4894        self.tls_required = tls_required if tls_required is not None else False
4895        '''
4896
4897        '''
4898        self.username = username if username is not None else ''
4899        '''
4900
4901        '''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
4920    def to_dict(self):
4921        return {
4922            'bind_interface': self.bind_interface,
4923            'egress_filter': self.egress_filter,
4924            'healthy': self.healthy,
4925            'hostname': self.hostname,
4926            'id': self.id,
4927            'name': self.name,
4928            'password': self.password,
4929            'port': self.port,
4930            'port_override': self.port_override,
4931            'secret_store_id': self.secret_store_id,
4932            'tags': self.tags,
4933            'tls_required': self.tls_required,
4934            'username': self.username,
4935        }
@classmethod
def from_dict(cls, d)
4937    @classmethod
4938    def from_dict(cls, d):
4939        return cls(
4940            bind_interface=d.get('bind_interface'),
4941            egress_filter=d.get('egress_filter'),
4942            healthy=d.get('healthy'),
4943            hostname=d.get('hostname'),
4944            id=d.get('id'),
4945            name=d.get('name'),
4946            password=d.get('password'),
4947            port=d.get('port'),
4948            port_override=d.get('port_override'),
4949            secret_store_id=d.get('secret_store_id'),
4950            tags=d.get('tags'),
4951            tls_required=d.get('tls_required'),
4952            username=d.get('username'),
4953        )
class ElasticacheRedis:
4956class ElasticacheRedis:
4957    '''
4958
4959    '''
4960    __slots__ = [
4961        'bind_interface',
4962        'egress_filter',
4963        'healthy',
4964        'hostname',
4965        'id',
4966        'name',
4967        'password',
4968        'port',
4969        'port_override',
4970        'secret_store_id',
4971        'tags',
4972        'tls_required',
4973    ]
4974
4975    def __init__(
4976        self,
4977        bind_interface=None,
4978        egress_filter=None,
4979        healthy=None,
4980        hostname=None,
4981        id=None,
4982        name=None,
4983        password=None,
4984        port=None,
4985        port_override=None,
4986        secret_store_id=None,
4987        tags=None,
4988        tls_required=None,
4989    ):
4990        self.bind_interface = bind_interface if bind_interface is not None else ''
4991        '''
4992         Bind interface
4993        '''
4994        self.egress_filter = egress_filter if egress_filter is not None else ''
4995        '''
4996         A filter applied to the routing logic to pin datasource to nodes.
4997        '''
4998        self.healthy = healthy if healthy is not None else False
4999        '''
5000         True if the datasource is reachable and the credentials are valid.
5001        '''
5002        self.hostname = hostname if hostname is not None else ''
5003        '''
5004
5005        '''
5006        self.id = id if id is not None else ''
5007        '''
5008         Unique identifier of the Resource.
5009        '''
5010        self.name = name if name is not None else ''
5011        '''
5012         Unique human-readable name of the Resource.
5013        '''
5014        self.password = password if password is not None else ''
5015        '''
5016
5017        '''
5018        self.port = port if port is not None else 0
5019        '''
5020
5021        '''
5022        self.port_override = port_override if port_override is not None else 0
5023        '''
5024
5025        '''
5026        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5027        '''
5028         ID of the secret store containing credentials for this resource, if any.
5029        '''
5030        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5031        '''
5032         Tags is a map of key, value pairs.
5033        '''
5034        self.tls_required = tls_required if tls_required is not None else False
5035        '''
5036
5037        '''
5038
5039    def __repr__(self):
5040        return '<sdm.ElasticacheRedis ' + \
5041            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
5042            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
5043            'healthy: ' + repr(self.healthy) + ' ' +\
5044            'hostname: ' + repr(self.hostname) + ' ' +\
5045            'id: ' + repr(self.id) + ' ' +\
5046            'name: ' + repr(self.name) + ' ' +\
5047            'password: ' + repr(self.password) + ' ' +\
5048            'port: ' + repr(self.port) + ' ' +\
5049            'port_override: ' + repr(self.port_override) + ' ' +\
5050            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
5051            'tags: ' + repr(self.tags) + ' ' +\
5052            'tls_required: ' + repr(self.tls_required) + ' ' +\
5053            '>'
5054
5055    def to_dict(self):
5056        return {
5057            'bind_interface': self.bind_interface,
5058            'egress_filter': self.egress_filter,
5059            'healthy': self.healthy,
5060            'hostname': self.hostname,
5061            'id': self.id,
5062            'name': self.name,
5063            'password': self.password,
5064            'port': self.port,
5065            'port_override': self.port_override,
5066            'secret_store_id': self.secret_store_id,
5067            'tags': self.tags,
5068            'tls_required': self.tls_required,
5069        }
5070
5071    @classmethod
5072    def from_dict(cls, d):
5073        return cls(
5074            bind_interface=d.get('bind_interface'),
5075            egress_filter=d.get('egress_filter'),
5076            healthy=d.get('healthy'),
5077            hostname=d.get('hostname'),
5078            id=d.get('id'),
5079            name=d.get('name'),
5080            password=d.get('password'),
5081            port=d.get('port'),
5082            port_override=d.get('port_override'),
5083            secret_store_id=d.get('secret_store_id'),
5084            tags=d.get('tags'),
5085            tls_required=d.get('tls_required'),
5086        )
ElasticacheRedis( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, tls_required=None)
4975    def __init__(
4976        self,
4977        bind_interface=None,
4978        egress_filter=None,
4979        healthy=None,
4980        hostname=None,
4981        id=None,
4982        name=None,
4983        password=None,
4984        port=None,
4985        port_override=None,
4986        secret_store_id=None,
4987        tags=None,
4988        tls_required=None,
4989    ):
4990        self.bind_interface = bind_interface if bind_interface is not None else ''
4991        '''
4992         Bind interface
4993        '''
4994        self.egress_filter = egress_filter if egress_filter is not None else ''
4995        '''
4996         A filter applied to the routing logic to pin datasource to nodes.
4997        '''
4998        self.healthy = healthy if healthy is not None else False
4999        '''
5000         True if the datasource is reachable and the credentials are valid.
5001        '''
5002        self.hostname = hostname if hostname is not None else ''
5003        '''
5004
5005        '''
5006        self.id = id if id is not None else ''
5007        '''
5008         Unique identifier of the Resource.
5009        '''
5010        self.name = name if name is not None else ''
5011        '''
5012         Unique human-readable name of the Resource.
5013        '''
5014        self.password = password if password is not None else ''
5015        '''
5016
5017        '''
5018        self.port = port if port is not None else 0
5019        '''
5020
5021        '''
5022        self.port_override = port_override if port_override is not None else 0
5023        '''
5024
5025        '''
5026        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5027        '''
5028         ID of the secret store containing credentials for this resource, if any.
5029        '''
5030        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5031        '''
5032         Tags is a map of key, value pairs.
5033        '''
5034        self.tls_required = tls_required if tls_required is not None else False
5035        '''
5036
5037        '''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
def to_dict(self)
5055    def to_dict(self):
5056        return {
5057            'bind_interface': self.bind_interface,
5058            'egress_filter': self.egress_filter,
5059            'healthy': self.healthy,
5060            'hostname': self.hostname,
5061            'id': self.id,
5062            'name': self.name,
5063            'password': self.password,
5064            'port': self.port,
5065            'port_override': self.port_override,
5066            'secret_store_id': self.secret_store_id,
5067            'tags': self.tags,
5068            'tls_required': self.tls_required,
5069        }
@classmethod
def from_dict(cls, d)
5071    @classmethod
5072    def from_dict(cls, d):
5073        return cls(
5074            bind_interface=d.get('bind_interface'),
5075            egress_filter=d.get('egress_filter'),
5076            healthy=d.get('healthy'),
5077            hostname=d.get('hostname'),
5078            id=d.get('id'),
5079            name=d.get('name'),
5080            password=d.get('password'),
5081            port=d.get('port'),
5082            port_override=d.get('port_override'),
5083            secret_store_id=d.get('secret_store_id'),
5084            tags=d.get('tags'),
5085            tls_required=d.get('tls_required'),
5086        )
class GCP:
5089class GCP:
5090    '''
5091
5092    '''
5093    __slots__ = [
5094        'bind_interface',
5095        'egress_filter',
5096        'healthy',
5097        'id',
5098        'keyfile',
5099        'name',
5100        'scopes',
5101        'secret_store_id',
5102        'tags',
5103    ]
5104
5105    def __init__(
5106        self,
5107        bind_interface=None,
5108        egress_filter=None,
5109        healthy=None,
5110        id=None,
5111        keyfile=None,
5112        name=None,
5113        scopes=None,
5114        secret_store_id=None,
5115        tags=None,
5116    ):
5117        self.bind_interface = bind_interface if bind_interface is not None else ''
5118        '''
5119         Bind interface
5120        '''
5121        self.egress_filter = egress_filter if egress_filter is not None else ''
5122        '''
5123         A filter applied to the routing logic to pin datasource to nodes.
5124        '''
5125        self.healthy = healthy if healthy is not None else False
5126        '''
5127         True if the datasource is reachable and the credentials are valid.
5128        '''
5129        self.id = id if id is not None else ''
5130        '''
5131         Unique identifier of the Resource.
5132        '''
5133        self.keyfile = keyfile if keyfile is not None else ''
5134        '''
5135
5136        '''
5137        self.name = name if name is not None else ''
5138        '''
5139         Unique human-readable name of the Resource.
5140        '''
5141        self.scopes = scopes if scopes is not None else ''
5142        '''
5143
5144        '''
5145        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5146        '''
5147         ID of the secret store containing credentials for this resource, if any.
5148        '''
5149        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5150        '''
5151         Tags is a map of key, value pairs.
5152        '''
5153
5154    def __repr__(self):
5155        return '<sdm.GCP ' + \
5156            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
5157            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
5158            'healthy: ' + repr(self.healthy) + ' ' +\
5159            'id: ' + repr(self.id) + ' ' +\
5160            'keyfile: ' + repr(self.keyfile) + ' ' +\
5161            'name: ' + repr(self.name) + ' ' +\
5162            'scopes: ' + repr(self.scopes) + ' ' +\
5163            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
5164            'tags: ' + repr(self.tags) + ' ' +\
5165            '>'
5166
5167    def to_dict(self):
5168        return {
5169            'bind_interface': self.bind_interface,
5170            'egress_filter': self.egress_filter,
5171            'healthy': self.healthy,
5172            'id': self.id,
5173            'keyfile': self.keyfile,
5174            'name': self.name,
5175            'scopes': self.scopes,
5176            'secret_store_id': self.secret_store_id,
5177            'tags': self.tags,
5178        }
5179
5180    @classmethod
5181    def from_dict(cls, d):
5182        return cls(
5183            bind_interface=d.get('bind_interface'),
5184            egress_filter=d.get('egress_filter'),
5185            healthy=d.get('healthy'),
5186            id=d.get('id'),
5187            keyfile=d.get('keyfile'),
5188            name=d.get('name'),
5189            scopes=d.get('scopes'),
5190            secret_store_id=d.get('secret_store_id'),
5191            tags=d.get('tags'),
5192        )
GCP( bind_interface=None, egress_filter=None, healthy=None, id=None, keyfile=None, name=None, scopes=None, secret_store_id=None, tags=None)
5105    def __init__(
5106        self,
5107        bind_interface=None,
5108        egress_filter=None,
5109        healthy=None,
5110        id=None,
5111        keyfile=None,
5112        name=None,
5113        scopes=None,
5114        secret_store_id=None,
5115        tags=None,
5116    ):
5117        self.bind_interface = bind_interface if bind_interface is not None else ''
5118        '''
5119         Bind interface
5120        '''
5121        self.egress_filter = egress_filter if egress_filter is not None else ''
5122        '''
5123         A filter applied to the routing logic to pin datasource to nodes.
5124        '''
5125        self.healthy = healthy if healthy is not None else False
5126        '''
5127         True if the datasource is reachable and the credentials are valid.
5128        '''
5129        self.id = id if id is not None else ''
5130        '''
5131         Unique identifier of the Resource.
5132        '''
5133        self.keyfile = keyfile if keyfile is not None else ''
5134        '''
5135
5136        '''
5137        self.name = name if name is not None else ''
5138        '''
5139         Unique human-readable name of the Resource.
5140        '''
5141        self.scopes = scopes if scopes is not None else ''
5142        '''
5143
5144        '''
5145        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5146        '''
5147         ID of the secret store containing credentials for this resource, if any.
5148        '''
5149        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5150        '''
5151         Tags is a map of key, value pairs.
5152        '''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

keyfile
name

Unique human-readable name of the Resource.

scopes
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
5167    def to_dict(self):
5168        return {
5169            'bind_interface': self.bind_interface,
5170            'egress_filter': self.egress_filter,
5171            'healthy': self.healthy,
5172            'id': self.id,
5173            'keyfile': self.keyfile,
5174            'name': self.name,
5175            'scopes': self.scopes,
5176            'secret_store_id': self.secret_store_id,
5177            'tags': self.tags,
5178        }
@classmethod
def from_dict(cls, d)
5180    @classmethod
5181    def from_dict(cls, d):
5182        return cls(
5183            bind_interface=d.get('bind_interface'),
5184            egress_filter=d.get('egress_filter'),
5185            healthy=d.get('healthy'),
5186            id=d.get('id'),
5187            keyfile=d.get('keyfile'),
5188            name=d.get('name'),
5189            scopes=d.get('scopes'),
5190            secret_store_id=d.get('secret_store_id'),
5191            tags=d.get('tags'),
5192        )
class GCPStore:
5195class GCPStore:
5196    '''
5197
5198    '''
5199    __slots__ = [
5200        'id',
5201        'name',
5202        'projectid',
5203        'tags',
5204    ]
5205
5206    def __init__(
5207        self,
5208        id=None,
5209        name=None,
5210        projectid=None,
5211        tags=None,
5212    ):
5213        self.id = id if id is not None else ''
5214        '''
5215         Unique identifier of the SecretStore.
5216        '''
5217        self.name = name if name is not None else ''
5218        '''
5219         Unique human-readable name of the SecretStore.
5220        '''
5221        self.projectid = projectid if projectid is not None else ''
5222        '''
5223
5224        '''
5225        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5226        '''
5227         Tags is a map of key, value pairs.
5228        '''
5229
5230    def __repr__(self):
5231        return '<sdm.GCPStore ' + \
5232            'id: ' + repr(self.id) + ' ' +\
5233            'name: ' + repr(self.name) + ' ' +\
5234            'projectid: ' + repr(self.projectid) + ' ' +\
5235            'tags: ' + repr(self.tags) + ' ' +\
5236            '>'
5237
5238    def to_dict(self):
5239        return {
5240            'id': self.id,
5241            'name': self.name,
5242            'projectid': self.projectid,
5243            'tags': self.tags,
5244        }
5245
5246    @classmethod
5247    def from_dict(cls, d):
5248        return cls(
5249            id=d.get('id'),
5250            name=d.get('name'),
5251            projectid=d.get('projectid'),
5252            tags=d.get('tags'),
5253        )
GCPStore(id=None, name=None, projectid=None, tags=None)
5206    def __init__(
5207        self,
5208        id=None,
5209        name=None,
5210        projectid=None,
5211        tags=None,
5212    ):
5213        self.id = id if id is not None else ''
5214        '''
5215         Unique identifier of the SecretStore.
5216        '''
5217        self.name = name if name is not None else ''
5218        '''
5219         Unique human-readable name of the SecretStore.
5220        '''
5221        self.projectid = projectid if projectid is not None else ''
5222        '''
5223
5224        '''
5225        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5226        '''
5227         Tags is a map of key, value pairs.
5228        '''
id

Unique identifier of the SecretStore.

name

Unique human-readable name of the SecretStore.

projectid
tags

Tags is a map of key, value pairs.

def to_dict(self)
5238    def to_dict(self):
5239        return {
5240            'id': self.id,
5241            'name': self.name,
5242            'projectid': self.projectid,
5243            'tags': self.tags,
5244        }
@classmethod
def from_dict(cls, d)
5246    @classmethod
5247    def from_dict(cls, d):
5248        return cls(
5249            id=d.get('id'),
5250            name=d.get('name'),
5251            projectid=d.get('projectid'),
5252            tags=d.get('tags'),
5253        )
class Gateway:
5256class Gateway:
5257    '''
5258     Gateway represents a StrongDM CLI installation running in gateway mode.
5259    '''
5260    __slots__ = [
5261        'bind_address',
5262        'gateway_filter',
5263        'id',
5264        'listen_address',
5265        'name',
5266        'state',
5267        'tags',
5268    ]
5269
5270    def __init__(
5271        self,
5272        bind_address=None,
5273        gateway_filter=None,
5274        id=None,
5275        listen_address=None,
5276        name=None,
5277        state=None,
5278        tags=None,
5279    ):
5280        self.bind_address = bind_address if bind_address is not None else ''
5281        '''
5282         The hostname/port tuple which the gateway daemon will bind to.
5283         If not provided on create, set to "0.0.0.0:listen_address_port".
5284        '''
5285        self.gateway_filter = gateway_filter if gateway_filter is not None else ''
5286        '''
5287         GatewayFilter can be used to restrict the peering between relays and
5288         gateways.
5289        '''
5290        self.id = id if id is not None else ''
5291        '''
5292         Unique identifier of the Gateway.
5293        '''
5294        self.listen_address = listen_address if listen_address is not None else ''
5295        '''
5296         The public hostname/port tuple at which the gateway will be accessible to clients.
5297        '''
5298        self.name = name if name is not None else ''
5299        '''
5300         Unique human-readable name of the Gateway. Node names must include only letters, numbers, and hyphens (no spaces, underscores, or other special characters). Generated if not provided on create.
5301        '''
5302        self.state = state if state is not None else ''
5303        '''
5304         The current state of the gateway. One of: "new", "verifying_restart",
5305         "restarting", "started", "stopped", "dead", "unknown"
5306        '''
5307        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5308        '''
5309         Tags is a map of key, value pairs.
5310        '''
5311
5312    def __repr__(self):
5313        return '<sdm.Gateway ' + \
5314            'bind_address: ' + repr(self.bind_address) + ' ' +\
5315            'gateway_filter: ' + repr(self.gateway_filter) + ' ' +\
5316            'id: ' + repr(self.id) + ' ' +\
5317            'listen_address: ' + repr(self.listen_address) + ' ' +\
5318            'name: ' + repr(self.name) + ' ' +\
5319            'state: ' + repr(self.state) + ' ' +\
5320            'tags: ' + repr(self.tags) + ' ' +\
5321            '>'
5322
5323    def to_dict(self):
5324        return {
5325            'bind_address': self.bind_address,
5326            'gateway_filter': self.gateway_filter,
5327            'id': self.id,
5328            'listen_address': self.listen_address,
5329            'name': self.name,
5330            'state': self.state,
5331            'tags': self.tags,
5332        }
5333
5334    @classmethod
5335    def from_dict(cls, d):
5336        return cls(
5337            bind_address=d.get('bind_address'),
5338            gateway_filter=d.get('gateway_filter'),
5339            id=d.get('id'),
5340            listen_address=d.get('listen_address'),
5341            name=d.get('name'),
5342            state=d.get('state'),
5343            tags=d.get('tags'),
5344        )

Gateway represents a StrongDM CLI installation running in gateway mode.

Gateway( bind_address=None, gateway_filter=None, id=None, listen_address=None, name=None, state=None, tags=None)
5270    def __init__(
5271        self,
5272        bind_address=None,
5273        gateway_filter=None,
5274        id=None,
5275        listen_address=None,
5276        name=None,
5277        state=None,
5278        tags=None,
5279    ):
5280        self.bind_address = bind_address if bind_address is not None else ''
5281        '''
5282         The hostname/port tuple which the gateway daemon will bind to.
5283         If not provided on create, set to "0.0.0.0:listen_address_port".
5284        '''
5285        self.gateway_filter = gateway_filter if gateway_filter is not None else ''
5286        '''
5287         GatewayFilter can be used to restrict the peering between relays and
5288         gateways.
5289        '''
5290        self.id = id if id is not None else ''
5291        '''
5292         Unique identifier of the Gateway.
5293        '''
5294        self.listen_address = listen_address if listen_address is not None else ''
5295        '''
5296         The public hostname/port tuple at which the gateway will be accessible to clients.
5297        '''
5298        self.name = name if name is not None else ''
5299        '''
5300         Unique human-readable name of the Gateway. Node names must include only letters, numbers, and hyphens (no spaces, underscores, or other special characters). Generated if not provided on create.
5301        '''
5302        self.state = state if state is not None else ''
5303        '''
5304         The current state of the gateway. One of: "new", "verifying_restart",
5305         "restarting", "started", "stopped", "dead", "unknown"
5306        '''
5307        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5308        '''
5309         Tags is a map of key, value pairs.
5310        '''
bind_address

The hostname/port tuple which the gateway daemon will bind to. If not provided on create, set to "0.0.0.0:listen_address_port".

gateway_filter

GatewayFilter can be used to restrict the peering between relays and gateways.

id

Unique identifier of the Gateway.

listen_address

The public hostname/port tuple at which the gateway will be accessible to clients.

name

Unique human-readable name of the Gateway. Node names must include only letters, numbers, and hyphens (no spaces, underscores, or other special characters). Generated if not provided on create.

state

The current state of the gateway. One of: "new", "verifying_restart", "restarting", "started", "stopped", "dead", "unknown"

tags

Tags is a map of key, value pairs.

def to_dict(self)
5323    def to_dict(self):
5324        return {
5325            'bind_address': self.bind_address,
5326            'gateway_filter': self.gateway_filter,
5327            'id': self.id,
5328            'listen_address': self.listen_address,
5329            'name': self.name,
5330            'state': self.state,
5331            'tags': self.tags,
5332        }
@classmethod
def from_dict(cls, d)
5334    @classmethod
5335    def from_dict(cls, d):
5336        return cls(
5337            bind_address=d.get('bind_address'),
5338            gateway_filter=d.get('gateway_filter'),
5339            id=d.get('id'),
5340            listen_address=d.get('listen_address'),
5341            name=d.get('name'),
5342            state=d.get('state'),
5343            tags=d.get('tags'),
5344        )
class GetResponseMetadata:
5347class GetResponseMetadata:
5348    '''
5349     GetResponseMetadata is reserved for future use.
5350    '''
5351    __slots__ = []
5352
5353    def __init__(self, ):
5354        pass
5355
5356    def __repr__(self):
5357        return '<sdm.GetResponseMetadata ' + \
5358            '>'
5359
5360    def to_dict(self):
5361        return {}
5362
5363    @classmethod
5364    def from_dict(cls, d):
5365        return cls()

GetResponseMetadata is reserved for future use.

GetResponseMetadata()
5353    def __init__(self, ):
5354        pass
def to_dict(self)
5360    def to_dict(self):
5361        return {}
@classmethod
def from_dict(cls, d)
5363    @classmethod
5364    def from_dict(cls, d):
5365        return cls()
class GoogleGKE:
5368class GoogleGKE:
5369    '''
5370
5371    '''
5372    __slots__ = [
5373        'bind_interface',
5374        'certificate_authority',
5375        'egress_filter',
5376        'endpoint',
5377        'healthcheck_namespace',
5378        'healthy',
5379        'id',
5380        'name',
5381        'remote_identity_group_id',
5382        'remote_identity_healthcheck_username',
5383        'secret_store_id',
5384        'service_account_key',
5385        'tags',
5386    ]
5387
5388    def __init__(
5389        self,
5390        bind_interface=None,
5391        certificate_authority=None,
5392        egress_filter=None,
5393        endpoint=None,
5394        healthcheck_namespace=None,
5395        healthy=None,
5396        id=None,
5397        name=None,
5398        remote_identity_group_id=None,
5399        remote_identity_healthcheck_username=None,
5400        secret_store_id=None,
5401        service_account_key=None,
5402        tags=None,
5403    ):
5404        self.bind_interface = bind_interface if bind_interface is not None else ''
5405        '''
5406         Bind interface
5407        '''
5408        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
5409        '''
5410
5411        '''
5412        self.egress_filter = egress_filter if egress_filter is not None else ''
5413        '''
5414         A filter applied to the routing logic to pin datasource to nodes.
5415        '''
5416        self.endpoint = endpoint if endpoint is not None else ''
5417        '''
5418
5419        '''
5420        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
5421        '''
5422         The path used to check the health of your connection.  Defaults to `default`.
5423        '''
5424        self.healthy = healthy if healthy is not None else False
5425        '''
5426         True if the datasource is reachable and the credentials are valid.
5427        '''
5428        self.id = id if id is not None else ''
5429        '''
5430         Unique identifier of the Resource.
5431        '''
5432        self.name = name if name is not None else ''
5433        '''
5434         Unique human-readable name of the Resource.
5435        '''
5436        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
5437        '''
5438
5439        '''
5440        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
5441        '''
5442
5443        '''
5444        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5445        '''
5446         ID of the secret store containing credentials for this resource, if any.
5447        '''
5448        self.service_account_key = service_account_key if service_account_key is not None else ''
5449        '''
5450
5451        '''
5452        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5453        '''
5454         Tags is a map of key, value pairs.
5455        '''
5456
5457    def __repr__(self):
5458        return '<sdm.GoogleGKE ' + \
5459            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
5460            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
5461            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
5462            'endpoint: ' + repr(self.endpoint) + ' ' +\
5463            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
5464            'healthy: ' + repr(self.healthy) + ' ' +\
5465            'id: ' + repr(self.id) + ' ' +\
5466            'name: ' + repr(self.name) + ' ' +\
5467            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
5468            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
5469            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
5470            'service_account_key: ' + repr(self.service_account_key) + ' ' +\
5471            'tags: ' + repr(self.tags) + ' ' +\
5472            '>'
5473
5474    def to_dict(self):
5475        return {
5476            'bind_interface': self.bind_interface,
5477            'certificate_authority': self.certificate_authority,
5478            'egress_filter': self.egress_filter,
5479            'endpoint': self.endpoint,
5480            'healthcheck_namespace': self.healthcheck_namespace,
5481            'healthy': self.healthy,
5482            'id': self.id,
5483            'name': self.name,
5484            'remote_identity_group_id': self.remote_identity_group_id,
5485            'remote_identity_healthcheck_username':
5486            self.remote_identity_healthcheck_username,
5487            'secret_store_id': self.secret_store_id,
5488            'service_account_key': self.service_account_key,
5489            'tags': self.tags,
5490        }
5491
5492    @classmethod
5493    def from_dict(cls, d):
5494        return cls(
5495            bind_interface=d.get('bind_interface'),
5496            certificate_authority=d.get('certificate_authority'),
5497            egress_filter=d.get('egress_filter'),
5498            endpoint=d.get('endpoint'),
5499            healthcheck_namespace=d.get('healthcheck_namespace'),
5500            healthy=d.get('healthy'),
5501            id=d.get('id'),
5502            name=d.get('name'),
5503            remote_identity_group_id=d.get('remote_identity_group_id'),
5504            remote_identity_healthcheck_username=d.get(
5505                'remote_identity_healthcheck_username'),
5506            secret_store_id=d.get('secret_store_id'),
5507            service_account_key=d.get('service_account_key'),
5508            tags=d.get('tags'),
5509        )
GoogleGKE( bind_interface=None, certificate_authority=None, egress_filter=None, endpoint=None, healthcheck_namespace=None, healthy=None, id=None, name=None, remote_identity_group_id=None, remote_identity_healthcheck_username=None, secret_store_id=None, service_account_key=None, tags=None)
5388    def __init__(
5389        self,
5390        bind_interface=None,
5391        certificate_authority=None,
5392        egress_filter=None,
5393        endpoint=None,
5394        healthcheck_namespace=None,
5395        healthy=None,
5396        id=None,
5397        name=None,
5398        remote_identity_group_id=None,
5399        remote_identity_healthcheck_username=None,
5400        secret_store_id=None,
5401        service_account_key=None,
5402        tags=None,
5403    ):
5404        self.bind_interface = bind_interface if bind_interface is not None else ''
5405        '''
5406         Bind interface
5407        '''
5408        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
5409        '''
5410
5411        '''
5412        self.egress_filter = egress_filter if egress_filter is not None else ''
5413        '''
5414         A filter applied to the routing logic to pin datasource to nodes.
5415        '''
5416        self.endpoint = endpoint if endpoint is not None else ''
5417        '''
5418
5419        '''
5420        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
5421        '''
5422         The path used to check the health of your connection.  Defaults to `default`.
5423        '''
5424        self.healthy = healthy if healthy is not None else False
5425        '''
5426         True if the datasource is reachable and the credentials are valid.
5427        '''
5428        self.id = id if id is not None else ''
5429        '''
5430         Unique identifier of the Resource.
5431        '''
5432        self.name = name if name is not None else ''
5433        '''
5434         Unique human-readable name of the Resource.
5435        '''
5436        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
5437        '''
5438
5439        '''
5440        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
5441        '''
5442
5443        '''
5444        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5445        '''
5446         ID of the secret store containing credentials for this resource, if any.
5447        '''
5448        self.service_account_key = service_account_key if service_account_key is not None else ''
5449        '''
5450
5451        '''
5452        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5453        '''
5454         Tags is a map of key, value pairs.
5455        '''
bind_interface

Bind interface

certificate_authority
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

endpoint
healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

remote_identity_group_id
remote_identity_healthcheck_username
secret_store_id

ID of the secret store containing credentials for this resource, if any.

service_account_key
tags

Tags is a map of key, value pairs.

def to_dict(self)
5474    def to_dict(self):
5475        return {
5476            'bind_interface': self.bind_interface,
5477            'certificate_authority': self.certificate_authority,
5478            'egress_filter': self.egress_filter,
5479            'endpoint': self.endpoint,
5480            'healthcheck_namespace': self.healthcheck_namespace,
5481            'healthy': self.healthy,
5482            'id': self.id,
5483            'name': self.name,
5484            'remote_identity_group_id': self.remote_identity_group_id,
5485            'remote_identity_healthcheck_username':
5486            self.remote_identity_healthcheck_username,
5487            'secret_store_id': self.secret_store_id,
5488            'service_account_key': self.service_account_key,
5489            'tags': self.tags,
5490        }
@classmethod
def from_dict(cls, d)
5492    @classmethod
5493    def from_dict(cls, d):
5494        return cls(
5495            bind_interface=d.get('bind_interface'),
5496            certificate_authority=d.get('certificate_authority'),
5497            egress_filter=d.get('egress_filter'),
5498            endpoint=d.get('endpoint'),
5499            healthcheck_namespace=d.get('healthcheck_namespace'),
5500            healthy=d.get('healthy'),
5501            id=d.get('id'),
5502            name=d.get('name'),
5503            remote_identity_group_id=d.get('remote_identity_group_id'),
5504            remote_identity_healthcheck_username=d.get(
5505                'remote_identity_healthcheck_username'),
5506            secret_store_id=d.get('secret_store_id'),
5507            service_account_key=d.get('service_account_key'),
5508            tags=d.get('tags'),
5509        )
class GoogleGKEUserImpersonation:
5512class GoogleGKEUserImpersonation:
5513    '''
5514
5515    '''
5516    __slots__ = [
5517        'bind_interface',
5518        'certificate_authority',
5519        'egress_filter',
5520        'endpoint',
5521        'healthcheck_namespace',
5522        'healthy',
5523        'id',
5524        'name',
5525        'secret_store_id',
5526        'service_account_key',
5527        'tags',
5528    ]
5529
5530    def __init__(
5531        self,
5532        bind_interface=None,
5533        certificate_authority=None,
5534        egress_filter=None,
5535        endpoint=None,
5536        healthcheck_namespace=None,
5537        healthy=None,
5538        id=None,
5539        name=None,
5540        secret_store_id=None,
5541        service_account_key=None,
5542        tags=None,
5543    ):
5544        self.bind_interface = bind_interface if bind_interface is not None else ''
5545        '''
5546         Bind interface
5547        '''
5548        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
5549        '''
5550
5551        '''
5552        self.egress_filter = egress_filter if egress_filter is not None else ''
5553        '''
5554         A filter applied to the routing logic to pin datasource to nodes.
5555        '''
5556        self.endpoint = endpoint if endpoint is not None else ''
5557        '''
5558
5559        '''
5560        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
5561        '''
5562         The path used to check the health of your connection.  Defaults to `default`.
5563        '''
5564        self.healthy = healthy if healthy is not None else False
5565        '''
5566         True if the datasource is reachable and the credentials are valid.
5567        '''
5568        self.id = id if id is not None else ''
5569        '''
5570         Unique identifier of the Resource.
5571        '''
5572        self.name = name if name is not None else ''
5573        '''
5574         Unique human-readable name of the Resource.
5575        '''
5576        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5577        '''
5578         ID of the secret store containing credentials for this resource, if any.
5579        '''
5580        self.service_account_key = service_account_key if service_account_key is not None else ''
5581        '''
5582
5583        '''
5584        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5585        '''
5586         Tags is a map of key, value pairs.
5587        '''
5588
5589    def __repr__(self):
5590        return '<sdm.GoogleGKEUserImpersonation ' + \
5591            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
5592            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
5593            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
5594            'endpoint: ' + repr(self.endpoint) + ' ' +\
5595            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
5596            'healthy: ' + repr(self.healthy) + ' ' +\
5597            'id: ' + repr(self.id) + ' ' +\
5598            'name: ' + repr(self.name) + ' ' +\
5599            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
5600            'service_account_key: ' + repr(self.service_account_key) + ' ' +\
5601            'tags: ' + repr(self.tags) + ' ' +\
5602            '>'
5603
5604    def to_dict(self):
5605        return {
5606            'bind_interface': self.bind_interface,
5607            'certificate_authority': self.certificate_authority,
5608            'egress_filter': self.egress_filter,
5609            'endpoint': self.endpoint,
5610            'healthcheck_namespace': self.healthcheck_namespace,
5611            'healthy': self.healthy,
5612            'id': self.id,
5613            'name': self.name,
5614            'secret_store_id': self.secret_store_id,
5615            'service_account_key': self.service_account_key,
5616            'tags': self.tags,
5617        }
5618
5619    @classmethod
5620    def from_dict(cls, d):
5621        return cls(
5622            bind_interface=d.get('bind_interface'),
5623            certificate_authority=d.get('certificate_authority'),
5624            egress_filter=d.get('egress_filter'),
5625            endpoint=d.get('endpoint'),
5626            healthcheck_namespace=d.get('healthcheck_namespace'),
5627            healthy=d.get('healthy'),
5628            id=d.get('id'),
5629            name=d.get('name'),
5630            secret_store_id=d.get('secret_store_id'),
5631            service_account_key=d.get('service_account_key'),
5632            tags=d.get('tags'),
5633        )
GoogleGKEUserImpersonation( bind_interface=None, certificate_authority=None, egress_filter=None, endpoint=None, healthcheck_namespace=None, healthy=None, id=None, name=None, secret_store_id=None, service_account_key=None, tags=None)
5530    def __init__(
5531        self,
5532        bind_interface=None,
5533        certificate_authority=None,
5534        egress_filter=None,
5535        endpoint=None,
5536        healthcheck_namespace=None,
5537        healthy=None,
5538        id=None,
5539        name=None,
5540        secret_store_id=None,
5541        service_account_key=None,
5542        tags=None,
5543    ):
5544        self.bind_interface = bind_interface if bind_interface is not None else ''
5545        '''
5546         Bind interface
5547        '''
5548        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
5549        '''
5550
5551        '''
5552        self.egress_filter = egress_filter if egress_filter is not None else ''
5553        '''
5554         A filter applied to the routing logic to pin datasource to nodes.
5555        '''
5556        self.endpoint = endpoint if endpoint is not None else ''
5557        '''
5558
5559        '''
5560        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
5561        '''
5562         The path used to check the health of your connection.  Defaults to `default`.
5563        '''
5564        self.healthy = healthy if healthy is not None else False
5565        '''
5566         True if the datasource is reachable and the credentials are valid.
5567        '''
5568        self.id = id if id is not None else ''
5569        '''
5570         Unique identifier of the Resource.
5571        '''
5572        self.name = name if name is not None else ''
5573        '''
5574         Unique human-readable name of the Resource.
5575        '''
5576        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5577        '''
5578         ID of the secret store containing credentials for this resource, if any.
5579        '''
5580        self.service_account_key = service_account_key if service_account_key is not None else ''
5581        '''
5582
5583        '''
5584        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5585        '''
5586         Tags is a map of key, value pairs.
5587        '''
bind_interface

Bind interface

certificate_authority
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

endpoint
healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

secret_store_id

ID of the secret store containing credentials for this resource, if any.

service_account_key
tags

Tags is a map of key, value pairs.

def to_dict(self)
5604    def to_dict(self):
5605        return {
5606            'bind_interface': self.bind_interface,
5607            'certificate_authority': self.certificate_authority,
5608            'egress_filter': self.egress_filter,
5609            'endpoint': self.endpoint,
5610            'healthcheck_namespace': self.healthcheck_namespace,
5611            'healthy': self.healthy,
5612            'id': self.id,
5613            'name': self.name,
5614            'secret_store_id': self.secret_store_id,
5615            'service_account_key': self.service_account_key,
5616            'tags': self.tags,
5617        }
@classmethod
def from_dict(cls, d)
5619    @classmethod
5620    def from_dict(cls, d):
5621        return cls(
5622            bind_interface=d.get('bind_interface'),
5623            certificate_authority=d.get('certificate_authority'),
5624            egress_filter=d.get('egress_filter'),
5625            endpoint=d.get('endpoint'),
5626            healthcheck_namespace=d.get('healthcheck_namespace'),
5627            healthy=d.get('healthy'),
5628            id=d.get('id'),
5629            name=d.get('name'),
5630            secret_store_id=d.get('secret_store_id'),
5631            service_account_key=d.get('service_account_key'),
5632            tags=d.get('tags'),
5633        )
class Greenplum:
5636class Greenplum:
5637    '''
5638
5639    '''
5640    __slots__ = [
5641        'bind_interface',
5642        'database',
5643        'egress_filter',
5644        'healthy',
5645        'hostname',
5646        'id',
5647        'name',
5648        'override_database',
5649        'password',
5650        'port',
5651        'port_override',
5652        'secret_store_id',
5653        'tags',
5654        'username',
5655    ]
5656
5657    def __init__(
5658        self,
5659        bind_interface=None,
5660        database=None,
5661        egress_filter=None,
5662        healthy=None,
5663        hostname=None,
5664        id=None,
5665        name=None,
5666        override_database=None,
5667        password=None,
5668        port=None,
5669        port_override=None,
5670        secret_store_id=None,
5671        tags=None,
5672        username=None,
5673    ):
5674        self.bind_interface = bind_interface if bind_interface is not None else ''
5675        '''
5676         Bind interface
5677        '''
5678        self.database = database if database is not None else ''
5679        '''
5680
5681        '''
5682        self.egress_filter = egress_filter if egress_filter is not None else ''
5683        '''
5684         A filter applied to the routing logic to pin datasource to nodes.
5685        '''
5686        self.healthy = healthy if healthy is not None else False
5687        '''
5688         True if the datasource is reachable and the credentials are valid.
5689        '''
5690        self.hostname = hostname if hostname is not None else ''
5691        '''
5692
5693        '''
5694        self.id = id if id is not None else ''
5695        '''
5696         Unique identifier of the Resource.
5697        '''
5698        self.name = name if name is not None else ''
5699        '''
5700         Unique human-readable name of the Resource.
5701        '''
5702        self.override_database = override_database if override_database is not None else False
5703        '''
5704
5705        '''
5706        self.password = password if password is not None else ''
5707        '''
5708
5709        '''
5710        self.port = port if port is not None else 0
5711        '''
5712
5713        '''
5714        self.port_override = port_override if port_override is not None else 0
5715        '''
5716
5717        '''
5718        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5719        '''
5720         ID of the secret store containing credentials for this resource, if any.
5721        '''
5722        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5723        '''
5724         Tags is a map of key, value pairs.
5725        '''
5726        self.username = username if username is not None else ''
5727        '''
5728
5729        '''
5730
5731    def __repr__(self):
5732        return '<sdm.Greenplum ' + \
5733            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
5734            'database: ' + repr(self.database) + ' ' +\
5735            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
5736            'healthy: ' + repr(self.healthy) + ' ' +\
5737            'hostname: ' + repr(self.hostname) + ' ' +\
5738            'id: ' + repr(self.id) + ' ' +\
5739            'name: ' + repr(self.name) + ' ' +\
5740            'override_database: ' + repr(self.override_database) + ' ' +\
5741            'password: ' + repr(self.password) + ' ' +\
5742            'port: ' + repr(self.port) + ' ' +\
5743            'port_override: ' + repr(self.port_override) + ' ' +\
5744            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
5745            'tags: ' + repr(self.tags) + ' ' +\
5746            'username: ' + repr(self.username) + ' ' +\
5747            '>'
5748
5749    def to_dict(self):
5750        return {
5751            'bind_interface': self.bind_interface,
5752            'database': self.database,
5753            'egress_filter': self.egress_filter,
5754            'healthy': self.healthy,
5755            'hostname': self.hostname,
5756            'id': self.id,
5757            'name': self.name,
5758            'override_database': self.override_database,
5759            'password': self.password,
5760            'port': self.port,
5761            'port_override': self.port_override,
5762            'secret_store_id': self.secret_store_id,
5763            'tags': self.tags,
5764            'username': self.username,
5765        }
5766
5767    @classmethod
5768    def from_dict(cls, d):
5769        return cls(
5770            bind_interface=d.get('bind_interface'),
5771            database=d.get('database'),
5772            egress_filter=d.get('egress_filter'),
5773            healthy=d.get('healthy'),
5774            hostname=d.get('hostname'),
5775            id=d.get('id'),
5776            name=d.get('name'),
5777            override_database=d.get('override_database'),
5778            password=d.get('password'),
5779            port=d.get('port'),
5780            port_override=d.get('port_override'),
5781            secret_store_id=d.get('secret_store_id'),
5782            tags=d.get('tags'),
5783            username=d.get('username'),
5784        )
Greenplum( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, override_database=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
5657    def __init__(
5658        self,
5659        bind_interface=None,
5660        database=None,
5661        egress_filter=None,
5662        healthy=None,
5663        hostname=None,
5664        id=None,
5665        name=None,
5666        override_database=None,
5667        password=None,
5668        port=None,
5669        port_override=None,
5670        secret_store_id=None,
5671        tags=None,
5672        username=None,
5673    ):
5674        self.bind_interface = bind_interface if bind_interface is not None else ''
5675        '''
5676         Bind interface
5677        '''
5678        self.database = database if database is not None else ''
5679        '''
5680
5681        '''
5682        self.egress_filter = egress_filter if egress_filter is not None else ''
5683        '''
5684         A filter applied to the routing logic to pin datasource to nodes.
5685        '''
5686        self.healthy = healthy if healthy is not None else False
5687        '''
5688         True if the datasource is reachable and the credentials are valid.
5689        '''
5690        self.hostname = hostname if hostname is not None else ''
5691        '''
5692
5693        '''
5694        self.id = id if id is not None else ''
5695        '''
5696         Unique identifier of the Resource.
5697        '''
5698        self.name = name if name is not None else ''
5699        '''
5700         Unique human-readable name of the Resource.
5701        '''
5702        self.override_database = override_database if override_database is not None else False
5703        '''
5704
5705        '''
5706        self.password = password if password is not None else ''
5707        '''
5708
5709        '''
5710        self.port = port if port is not None else 0
5711        '''
5712
5713        '''
5714        self.port_override = port_override if port_override is not None else 0
5715        '''
5716
5717        '''
5718        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5719        '''
5720         ID of the secret store containing credentials for this resource, if any.
5721        '''
5722        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5723        '''
5724         Tags is a map of key, value pairs.
5725        '''
5726        self.username = username if username is not None else ''
5727        '''
5728
5729        '''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

override_database
password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
5749    def to_dict(self):
5750        return {
5751            'bind_interface': self.bind_interface,
5752            'database': self.database,
5753            'egress_filter': self.egress_filter,
5754            'healthy': self.healthy,
5755            'hostname': self.hostname,
5756            'id': self.id,
5757            'name': self.name,
5758            'override_database': self.override_database,
5759            'password': self.password,
5760            'port': self.port,
5761            'port_override': self.port_override,
5762            'secret_store_id': self.secret_store_id,
5763            'tags': self.tags,
5764            'username': self.username,
5765        }
@classmethod
def from_dict(cls, d)
5767    @classmethod
5768    def from_dict(cls, d):
5769        return cls(
5770            bind_interface=d.get('bind_interface'),
5771            database=d.get('database'),
5772            egress_filter=d.get('egress_filter'),
5773            healthy=d.get('healthy'),
5774            hostname=d.get('hostname'),
5775            id=d.get('id'),
5776            name=d.get('name'),
5777            override_database=d.get('override_database'),
5778            password=d.get('password'),
5779            port=d.get('port'),
5780            port_override=d.get('port_override'),
5781            secret_store_id=d.get('secret_store_id'),
5782            tags=d.get('tags'),
5783            username=d.get('username'),
5784        )
class HTTPAuth:
5787class HTTPAuth:
5788    '''
5789
5790    '''
5791    __slots__ = [
5792        'auth_header',
5793        'bind_interface',
5794        'default_path',
5795        'egress_filter',
5796        'headers_blacklist',
5797        'healthcheck_path',
5798        'healthy',
5799        'id',
5800        'name',
5801        'secret_store_id',
5802        'subdomain',
5803        'tags',
5804        'url',
5805    ]
5806
5807    def __init__(
5808        self,
5809        auth_header=None,
5810        bind_interface=None,
5811        default_path=None,
5812        egress_filter=None,
5813        headers_blacklist=None,
5814        healthcheck_path=None,
5815        healthy=None,
5816        id=None,
5817        name=None,
5818        secret_store_id=None,
5819        subdomain=None,
5820        tags=None,
5821        url=None,
5822    ):
5823        self.auth_header = auth_header if auth_header is not None else ''
5824        '''
5825
5826        '''
5827        self.bind_interface = bind_interface if bind_interface is not None else ''
5828        '''
5829         Bind interface
5830        '''
5831        self.default_path = default_path if default_path is not None else ''
5832        '''
5833
5834        '''
5835        self.egress_filter = egress_filter if egress_filter is not None else ''
5836        '''
5837         A filter applied to the routing logic to pin datasource to nodes.
5838        '''
5839        self.headers_blacklist = headers_blacklist if headers_blacklist is not None else ''
5840        '''
5841
5842        '''
5843        self.healthcheck_path = healthcheck_path if healthcheck_path is not None else ''
5844        '''
5845
5846        '''
5847        self.healthy = healthy if healthy is not None else False
5848        '''
5849         True if the datasource is reachable and the credentials are valid.
5850        '''
5851        self.id = id if id is not None else ''
5852        '''
5853         Unique identifier of the Resource.
5854        '''
5855        self.name = name if name is not None else ''
5856        '''
5857         Unique human-readable name of the Resource.
5858        '''
5859        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5860        '''
5861         ID of the secret store containing credentials for this resource, if any.
5862        '''
5863        self.subdomain = subdomain if subdomain is not None else ''
5864        '''
5865
5866        '''
5867        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5868        '''
5869         Tags is a map of key, value pairs.
5870        '''
5871        self.url = url if url is not None else ''
5872        '''
5873
5874        '''
5875
5876    def __repr__(self):
5877        return '<sdm.HTTPAuth ' + \
5878            'auth_header: ' + repr(self.auth_header) + ' ' +\
5879            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
5880            'default_path: ' + repr(self.default_path) + ' ' +\
5881            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
5882            'headers_blacklist: ' + repr(self.headers_blacklist) + ' ' +\
5883            'healthcheck_path: ' + repr(self.healthcheck_path) + ' ' +\
5884            'healthy: ' + repr(self.healthy) + ' ' +\
5885            'id: ' + repr(self.id) + ' ' +\
5886            'name: ' + repr(self.name) + ' ' +\
5887            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
5888            'subdomain: ' + repr(self.subdomain) + ' ' +\
5889            'tags: ' + repr(self.tags) + ' ' +\
5890            'url: ' + repr(self.url) + ' ' +\
5891            '>'
5892
5893    def to_dict(self):
5894        return {
5895            'auth_header': self.auth_header,
5896            'bind_interface': self.bind_interface,
5897            'default_path': self.default_path,
5898            'egress_filter': self.egress_filter,
5899            'headers_blacklist': self.headers_blacklist,
5900            'healthcheck_path': self.healthcheck_path,
5901            'healthy': self.healthy,
5902            'id': self.id,
5903            'name': self.name,
5904            'secret_store_id': self.secret_store_id,
5905            'subdomain': self.subdomain,
5906            'tags': self.tags,
5907            'url': self.url,
5908        }
5909
5910    @classmethod
5911    def from_dict(cls, d):
5912        return cls(
5913            auth_header=d.get('auth_header'),
5914            bind_interface=d.get('bind_interface'),
5915            default_path=d.get('default_path'),
5916            egress_filter=d.get('egress_filter'),
5917            headers_blacklist=d.get('headers_blacklist'),
5918            healthcheck_path=d.get('healthcheck_path'),
5919            healthy=d.get('healthy'),
5920            id=d.get('id'),
5921            name=d.get('name'),
5922            secret_store_id=d.get('secret_store_id'),
5923            subdomain=d.get('subdomain'),
5924            tags=d.get('tags'),
5925            url=d.get('url'),
5926        )
HTTPAuth( auth_header=None, bind_interface=None, default_path=None, egress_filter=None, headers_blacklist=None, healthcheck_path=None, healthy=None, id=None, name=None, secret_store_id=None, subdomain=None, tags=None, url=None)
5807    def __init__(
5808        self,
5809        auth_header=None,
5810        bind_interface=None,
5811        default_path=None,
5812        egress_filter=None,
5813        headers_blacklist=None,
5814        healthcheck_path=None,
5815        healthy=None,
5816        id=None,
5817        name=None,
5818        secret_store_id=None,
5819        subdomain=None,
5820        tags=None,
5821        url=None,
5822    ):
5823        self.auth_header = auth_header if auth_header is not None else ''
5824        '''
5825
5826        '''
5827        self.bind_interface = bind_interface if bind_interface is not None else ''
5828        '''
5829         Bind interface
5830        '''
5831        self.default_path = default_path if default_path is not None else ''
5832        '''
5833
5834        '''
5835        self.egress_filter = egress_filter if egress_filter is not None else ''
5836        '''
5837         A filter applied to the routing logic to pin datasource to nodes.
5838        '''
5839        self.headers_blacklist = headers_blacklist if headers_blacklist is not None else ''
5840        '''
5841
5842        '''
5843        self.healthcheck_path = healthcheck_path if healthcheck_path is not None else ''
5844        '''
5845
5846        '''
5847        self.healthy = healthy if healthy is not None else False
5848        '''
5849         True if the datasource is reachable and the credentials are valid.
5850        '''
5851        self.id = id if id is not None else ''
5852        '''
5853         Unique identifier of the Resource.
5854        '''
5855        self.name = name if name is not None else ''
5856        '''
5857         Unique human-readable name of the Resource.
5858        '''
5859        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
5860        '''
5861         ID of the secret store containing credentials for this resource, if any.
5862        '''
5863        self.subdomain = subdomain if subdomain is not None else ''
5864        '''
5865
5866        '''
5867        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
5868        '''
5869         Tags is a map of key, value pairs.
5870        '''
5871        self.url = url if url is not None else ''
5872        '''
5873
5874        '''
auth_header
bind_interface

Bind interface

default_path
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

headers_blacklist
healthcheck_path
healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

secret_store_id

ID of the secret store containing credentials for this resource, if any.

subdomain
tags

Tags is a map of key, value pairs.

url
def to_dict(self)
5893    def to_dict(self):
5894        return {
5895            'auth_header': self.auth_header,
5896            'bind_interface': self.bind_interface,
5897            'default_path': self.default_path,
5898            'egress_filter': self.egress_filter,
5899            'headers_blacklist': self.headers_blacklist,
5900            'healthcheck_path': self.healthcheck_path,
5901            'healthy': self.healthy,
5902            'id': self.id,
5903            'name': self.name,
5904            'secret_store_id': self.secret_store_id,
5905            'subdomain': self.subdomain,
5906            'tags': self.tags,
5907            'url': self.url,
5908        }
@classmethod
def from_dict(cls, d)
5910    @classmethod
5911    def from_dict(cls, d):
5912        return cls(
5913            auth_header=d.get('auth_header'),
5914            bind_interface=d.get('bind_interface'),
5915            default_path=d.get('default_path'),
5916            egress_filter=d.get('egress_filter'),
5917            headers_blacklist=d.get('headers_blacklist'),
5918            healthcheck_path=d.get('healthcheck_path'),
5919            healthy=d.get('healthy'),
5920            id=d.get('id'),
5921            name=d.get('name'),
5922            secret_store_id=d.get('secret_store_id'),
5923            subdomain=d.get('subdomain'),
5924            tags=d.get('tags'),
5925            url=d.get('url'),
5926        )
class HTTPBasicAuth:
5929class HTTPBasicAuth:
5930    '''
5931
5932    '''
5933    __slots__ = [
5934        'bind_interface',
5935        'default_path',
5936        'egress_filter',
5937        'headers_blacklist',
5938        'healthcheck_path',
5939        'healthy',
5940        'id',
5941        'name',
5942        'password',
5943        'secret_store_id',
5944        'subdomain',
5945        'tags',
5946        'url',
5947        'username',
5948    ]
5949
5950    def __init__(
5951        self,
5952        bind_interface=None,
5953        default_path=None,
5954        egress_filter=None,
5955        headers_blacklist=None,
5956        healthcheck_path=None,
5957        healthy=None,
5958        id=None,
5959        name=None,
5960        password=None,
5961        secret_store_id=None,
5962        subdomain=None,
5963        tags=None,
5964        url=None,
5965        username=None,
5966    ):
5967        self.bind_interface = bind_interface if bind_interface is not None else ''
5968        '''
5969         Bind interface
5970        '''
5971        self.default_path = default_path if default_path is not None else ''
5972        '''
5973
5974        '''
5975        self.egress_filter = egress_filter if egress_filter is not None else ''
5976        '''
5977         A filter applied to the routing logic to pin datasource to nodes.
5978        '''
5979        self.headers_blacklist = headers_blacklist if headers_blacklist is not None else ''
5980        '''
5981
5982        '''
5983        self.healthcheck_path = healthcheck_path if healthcheck_path is not None else ''
5984        '''
5985
5986        '''
5987        self.healthy = healthy if healthy is not None else False
5988        '''
5989         True if the datasource is reachable and the credentials are valid.
5990        '''
5991        self.id = id if id is not None else ''
5992        '''
5993         Unique identifier of the Resource.
5994        '''
5995        self.name = name if name is not None else ''
5996        '''
5997         Unique human-readable name of the Resource.
5998        '''
5999        self.password = password if password is not None else ''
6000        '''
6001
6002        '''
6003        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6004        '''
6005         ID of the secret store containing credentials for this resource, if any.
6006        '''
6007        self.subdomain = subdomain if subdomain is not None else ''
6008        '''
6009
6010        '''
6011        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6012        '''
6013         Tags is a map of key, value pairs.
6014        '''
6015        self.url = url if url is not None else ''
6016        '''
6017
6018        '''
6019        self.username = username if username is not None else ''
6020        '''
6021
6022        '''
6023
6024    def __repr__(self):
6025        return '<sdm.HTTPBasicAuth ' + \
6026            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
6027            'default_path: ' + repr(self.default_path) + ' ' +\
6028            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
6029            'headers_blacklist: ' + repr(self.headers_blacklist) + ' ' +\
6030            'healthcheck_path: ' + repr(self.healthcheck_path) + ' ' +\
6031            'healthy: ' + repr(self.healthy) + ' ' +\
6032            'id: ' + repr(self.id) + ' ' +\
6033            'name: ' + repr(self.name) + ' ' +\
6034            'password: ' + repr(self.password) + ' ' +\
6035            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
6036            'subdomain: ' + repr(self.subdomain) + ' ' +\
6037            'tags: ' + repr(self.tags) + ' ' +\
6038            'url: ' + repr(self.url) + ' ' +\
6039            'username: ' + repr(self.username) + ' ' +\
6040            '>'
6041
6042    def to_dict(self):
6043        return {
6044            'bind_interface': self.bind_interface,
6045            'default_path': self.default_path,
6046            'egress_filter': self.egress_filter,
6047            'headers_blacklist': self.headers_blacklist,
6048            'healthcheck_path': self.healthcheck_path,
6049            'healthy': self.healthy,
6050            'id': self.id,
6051            'name': self.name,
6052            'password': self.password,
6053            'secret_store_id': self.secret_store_id,
6054            'subdomain': self.subdomain,
6055            'tags': self.tags,
6056            'url': self.url,
6057            'username': self.username,
6058        }
6059
6060    @classmethod
6061    def from_dict(cls, d):
6062        return cls(
6063            bind_interface=d.get('bind_interface'),
6064            default_path=d.get('default_path'),
6065            egress_filter=d.get('egress_filter'),
6066            headers_blacklist=d.get('headers_blacklist'),
6067            healthcheck_path=d.get('healthcheck_path'),
6068            healthy=d.get('healthy'),
6069            id=d.get('id'),
6070            name=d.get('name'),
6071            password=d.get('password'),
6072            secret_store_id=d.get('secret_store_id'),
6073            subdomain=d.get('subdomain'),
6074            tags=d.get('tags'),
6075            url=d.get('url'),
6076            username=d.get('username'),
6077        )
HTTPBasicAuth( bind_interface=None, default_path=None, egress_filter=None, headers_blacklist=None, healthcheck_path=None, healthy=None, id=None, name=None, password=None, secret_store_id=None, subdomain=None, tags=None, url=None, username=None)
5950    def __init__(
5951        self,
5952        bind_interface=None,
5953        default_path=None,
5954        egress_filter=None,
5955        headers_blacklist=None,
5956        healthcheck_path=None,
5957        healthy=None,
5958        id=None,
5959        name=None,
5960        password=None,
5961        secret_store_id=None,
5962        subdomain=None,
5963        tags=None,
5964        url=None,
5965        username=None,
5966    ):
5967        self.bind_interface = bind_interface if bind_interface is not None else ''
5968        '''
5969         Bind interface
5970        '''
5971        self.default_path = default_path if default_path is not None else ''
5972        '''
5973
5974        '''
5975        self.egress_filter = egress_filter if egress_filter is not None else ''
5976        '''
5977         A filter applied to the routing logic to pin datasource to nodes.
5978        '''
5979        self.headers_blacklist = headers_blacklist if headers_blacklist is not None else ''
5980        '''
5981
5982        '''
5983        self.healthcheck_path = healthcheck_path if healthcheck_path is not None else ''
5984        '''
5985
5986        '''
5987        self.healthy = healthy if healthy is not None else False
5988        '''
5989         True if the datasource is reachable and the credentials are valid.
5990        '''
5991        self.id = id if id is not None else ''
5992        '''
5993         Unique identifier of the Resource.
5994        '''
5995        self.name = name if name is not None else ''
5996        '''
5997         Unique human-readable name of the Resource.
5998        '''
5999        self.password = password if password is not None else ''
6000        '''
6001
6002        '''
6003        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6004        '''
6005         ID of the secret store containing credentials for this resource, if any.
6006        '''
6007        self.subdomain = subdomain if subdomain is not None else ''
6008        '''
6009
6010        '''
6011        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6012        '''
6013         Tags is a map of key, value pairs.
6014        '''
6015        self.url = url if url is not None else ''
6016        '''
6017
6018        '''
6019        self.username = username if username is not None else ''
6020        '''
6021
6022        '''
bind_interface

Bind interface

default_path
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

headers_blacklist
healthcheck_path
healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
secret_store_id

ID of the secret store containing credentials for this resource, if any.

subdomain
tags

Tags is a map of key, value pairs.

url
username
def to_dict(self)
6042    def to_dict(self):
6043        return {
6044            'bind_interface': self.bind_interface,
6045            'default_path': self.default_path,
6046            'egress_filter': self.egress_filter,
6047            'headers_blacklist': self.headers_blacklist,
6048            'healthcheck_path': self.healthcheck_path,
6049            'healthy': self.healthy,
6050            'id': self.id,
6051            'name': self.name,
6052            'password': self.password,
6053            'secret_store_id': self.secret_store_id,
6054            'subdomain': self.subdomain,
6055            'tags': self.tags,
6056            'url': self.url,
6057            'username': self.username,
6058        }
@classmethod
def from_dict(cls, d)
6060    @classmethod
6061    def from_dict(cls, d):
6062        return cls(
6063            bind_interface=d.get('bind_interface'),
6064            default_path=d.get('default_path'),
6065            egress_filter=d.get('egress_filter'),
6066            headers_blacklist=d.get('headers_blacklist'),
6067            healthcheck_path=d.get('healthcheck_path'),
6068            healthy=d.get('healthy'),
6069            id=d.get('id'),
6070            name=d.get('name'),
6071            password=d.get('password'),
6072            secret_store_id=d.get('secret_store_id'),
6073            subdomain=d.get('subdomain'),
6074            tags=d.get('tags'),
6075            url=d.get('url'),
6076            username=d.get('username'),
6077        )
class HTTPNoAuth:
6080class HTTPNoAuth:
6081    '''
6082
6083    '''
6084    __slots__ = [
6085        'bind_interface',
6086        'default_path',
6087        'egress_filter',
6088        'headers_blacklist',
6089        'healthcheck_path',
6090        'healthy',
6091        'id',
6092        'name',
6093        'secret_store_id',
6094        'subdomain',
6095        'tags',
6096        'url',
6097    ]
6098
6099    def __init__(
6100        self,
6101        bind_interface=None,
6102        default_path=None,
6103        egress_filter=None,
6104        headers_blacklist=None,
6105        healthcheck_path=None,
6106        healthy=None,
6107        id=None,
6108        name=None,
6109        secret_store_id=None,
6110        subdomain=None,
6111        tags=None,
6112        url=None,
6113    ):
6114        self.bind_interface = bind_interface if bind_interface is not None else ''
6115        '''
6116         Bind interface
6117        '''
6118        self.default_path = default_path if default_path is not None else ''
6119        '''
6120
6121        '''
6122        self.egress_filter = egress_filter if egress_filter is not None else ''
6123        '''
6124         A filter applied to the routing logic to pin datasource to nodes.
6125        '''
6126        self.headers_blacklist = headers_blacklist if headers_blacklist is not None else ''
6127        '''
6128
6129        '''
6130        self.healthcheck_path = healthcheck_path if healthcheck_path is not None else ''
6131        '''
6132
6133        '''
6134        self.healthy = healthy if healthy is not None else False
6135        '''
6136         True if the datasource is reachable and the credentials are valid.
6137        '''
6138        self.id = id if id is not None else ''
6139        '''
6140         Unique identifier of the Resource.
6141        '''
6142        self.name = name if name is not None else ''
6143        '''
6144         Unique human-readable name of the Resource.
6145        '''
6146        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6147        '''
6148         ID of the secret store containing credentials for this resource, if any.
6149        '''
6150        self.subdomain = subdomain if subdomain is not None else ''
6151        '''
6152
6153        '''
6154        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6155        '''
6156         Tags is a map of key, value pairs.
6157        '''
6158        self.url = url if url is not None else ''
6159        '''
6160
6161        '''
6162
6163    def __repr__(self):
6164        return '<sdm.HTTPNoAuth ' + \
6165            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
6166            'default_path: ' + repr(self.default_path) + ' ' +\
6167            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
6168            'headers_blacklist: ' + repr(self.headers_blacklist) + ' ' +\
6169            'healthcheck_path: ' + repr(self.healthcheck_path) + ' ' +\
6170            'healthy: ' + repr(self.healthy) + ' ' +\
6171            'id: ' + repr(self.id) + ' ' +\
6172            'name: ' + repr(self.name) + ' ' +\
6173            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
6174            'subdomain: ' + repr(self.subdomain) + ' ' +\
6175            'tags: ' + repr(self.tags) + ' ' +\
6176            'url: ' + repr(self.url) + ' ' +\
6177            '>'
6178
6179    def to_dict(self):
6180        return {
6181            'bind_interface': self.bind_interface,
6182            'default_path': self.default_path,
6183            'egress_filter': self.egress_filter,
6184            'headers_blacklist': self.headers_blacklist,
6185            'healthcheck_path': self.healthcheck_path,
6186            'healthy': self.healthy,
6187            'id': self.id,
6188            'name': self.name,
6189            'secret_store_id': self.secret_store_id,
6190            'subdomain': self.subdomain,
6191            'tags': self.tags,
6192            'url': self.url,
6193        }
6194
6195    @classmethod
6196    def from_dict(cls, d):
6197        return cls(
6198            bind_interface=d.get('bind_interface'),
6199            default_path=d.get('default_path'),
6200            egress_filter=d.get('egress_filter'),
6201            headers_blacklist=d.get('headers_blacklist'),
6202            healthcheck_path=d.get('healthcheck_path'),
6203            healthy=d.get('healthy'),
6204            id=d.get('id'),
6205            name=d.get('name'),
6206            secret_store_id=d.get('secret_store_id'),
6207            subdomain=d.get('subdomain'),
6208            tags=d.get('tags'),
6209            url=d.get('url'),
6210        )
HTTPNoAuth( bind_interface=None, default_path=None, egress_filter=None, headers_blacklist=None, healthcheck_path=None, healthy=None, id=None, name=None, secret_store_id=None, subdomain=None, tags=None, url=None)
6099    def __init__(
6100        self,
6101        bind_interface=None,
6102        default_path=None,
6103        egress_filter=None,
6104        headers_blacklist=None,
6105        healthcheck_path=None,
6106        healthy=None,
6107        id=None,
6108        name=None,
6109        secret_store_id=None,
6110        subdomain=None,
6111        tags=None,
6112        url=None,
6113    ):
6114        self.bind_interface = bind_interface if bind_interface is not None else ''
6115        '''
6116         Bind interface
6117        '''
6118        self.default_path = default_path if default_path is not None else ''
6119        '''
6120
6121        '''
6122        self.egress_filter = egress_filter if egress_filter is not None else ''
6123        '''
6124         A filter applied to the routing logic to pin datasource to nodes.
6125        '''
6126        self.headers_blacklist = headers_blacklist if headers_blacklist is not None else ''
6127        '''
6128
6129        '''
6130        self.healthcheck_path = healthcheck_path if healthcheck_path is not None else ''
6131        '''
6132
6133        '''
6134        self.healthy = healthy if healthy is not None else False
6135        '''
6136         True if the datasource is reachable and the credentials are valid.
6137        '''
6138        self.id = id if id is not None else ''
6139        '''
6140         Unique identifier of the Resource.
6141        '''
6142        self.name = name if name is not None else ''
6143        '''
6144         Unique human-readable name of the Resource.
6145        '''
6146        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6147        '''
6148         ID of the secret store containing credentials for this resource, if any.
6149        '''
6150        self.subdomain = subdomain if subdomain is not None else ''
6151        '''
6152
6153        '''
6154        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6155        '''
6156         Tags is a map of key, value pairs.
6157        '''
6158        self.url = url if url is not None else ''
6159        '''
6160
6161        '''
bind_interface

Bind interface

default_path
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

headers_blacklist
healthcheck_path
healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

secret_store_id

ID of the secret store containing credentials for this resource, if any.

subdomain
tags

Tags is a map of key, value pairs.

url
def to_dict(self)
6179    def to_dict(self):
6180        return {
6181            'bind_interface': self.bind_interface,
6182            'default_path': self.default_path,
6183            'egress_filter': self.egress_filter,
6184            'headers_blacklist': self.headers_blacklist,
6185            'healthcheck_path': self.healthcheck_path,
6186            'healthy': self.healthy,
6187            'id': self.id,
6188            'name': self.name,
6189            'secret_store_id': self.secret_store_id,
6190            'subdomain': self.subdomain,
6191            'tags': self.tags,
6192            'url': self.url,
6193        }
@classmethod
def from_dict(cls, d)
6195    @classmethod
6196    def from_dict(cls, d):
6197        return cls(
6198            bind_interface=d.get('bind_interface'),
6199            default_path=d.get('default_path'),
6200            egress_filter=d.get('egress_filter'),
6201            headers_blacklist=d.get('headers_blacklist'),
6202            healthcheck_path=d.get('healthcheck_path'),
6203            healthy=d.get('healthy'),
6204            id=d.get('id'),
6205            name=d.get('name'),
6206            secret_store_id=d.get('secret_store_id'),
6207            subdomain=d.get('subdomain'),
6208            tags=d.get('tags'),
6209            url=d.get('url'),
6210        )
class Kubernetes:
6213class Kubernetes:
6214    '''
6215
6216    '''
6217    __slots__ = [
6218        'bind_interface',
6219        'certificate_authority',
6220        'client_certificate',
6221        'client_key',
6222        'egress_filter',
6223        'healthcheck_namespace',
6224        'healthy',
6225        'hostname',
6226        'id',
6227        'name',
6228        'port',
6229        'remote_identity_group_id',
6230        'remote_identity_healthcheck_username',
6231        'secret_store_id',
6232        'tags',
6233    ]
6234
6235    def __init__(
6236        self,
6237        bind_interface=None,
6238        certificate_authority=None,
6239        client_certificate=None,
6240        client_key=None,
6241        egress_filter=None,
6242        healthcheck_namespace=None,
6243        healthy=None,
6244        hostname=None,
6245        id=None,
6246        name=None,
6247        port=None,
6248        remote_identity_group_id=None,
6249        remote_identity_healthcheck_username=None,
6250        secret_store_id=None,
6251        tags=None,
6252    ):
6253        self.bind_interface = bind_interface if bind_interface is not None else ''
6254        '''
6255         Bind interface
6256        '''
6257        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
6258        '''
6259
6260        '''
6261        self.client_certificate = client_certificate if client_certificate is not None else ''
6262        '''
6263
6264        '''
6265        self.client_key = client_key if client_key is not None else ''
6266        '''
6267
6268        '''
6269        self.egress_filter = egress_filter if egress_filter is not None else ''
6270        '''
6271         A filter applied to the routing logic to pin datasource to nodes.
6272        '''
6273        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
6274        '''
6275         The path used to check the health of your connection.  Defaults to `default`.
6276        '''
6277        self.healthy = healthy if healthy is not None else False
6278        '''
6279         True if the datasource is reachable and the credentials are valid.
6280        '''
6281        self.hostname = hostname if hostname is not None else ''
6282        '''
6283
6284        '''
6285        self.id = id if id is not None else ''
6286        '''
6287         Unique identifier of the Resource.
6288        '''
6289        self.name = name if name is not None else ''
6290        '''
6291         Unique human-readable name of the Resource.
6292        '''
6293        self.port = port if port is not None else 0
6294        '''
6295
6296        '''
6297        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
6298        '''
6299
6300        '''
6301        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
6302        '''
6303
6304        '''
6305        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6306        '''
6307         ID of the secret store containing credentials for this resource, if any.
6308        '''
6309        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6310        '''
6311         Tags is a map of key, value pairs.
6312        '''
6313
6314    def __repr__(self):
6315        return '<sdm.Kubernetes ' + \
6316            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
6317            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
6318            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
6319            'client_key: ' + repr(self.client_key) + ' ' +\
6320            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
6321            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
6322            'healthy: ' + repr(self.healthy) + ' ' +\
6323            'hostname: ' + repr(self.hostname) + ' ' +\
6324            'id: ' + repr(self.id) + ' ' +\
6325            'name: ' + repr(self.name) + ' ' +\
6326            'port: ' + repr(self.port) + ' ' +\
6327            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
6328            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
6329            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
6330            'tags: ' + repr(self.tags) + ' ' +\
6331            '>'
6332
6333    def to_dict(self):
6334        return {
6335            'bind_interface': self.bind_interface,
6336            'certificate_authority': self.certificate_authority,
6337            'client_certificate': self.client_certificate,
6338            'client_key': self.client_key,
6339            'egress_filter': self.egress_filter,
6340            'healthcheck_namespace': self.healthcheck_namespace,
6341            'healthy': self.healthy,
6342            'hostname': self.hostname,
6343            'id': self.id,
6344            'name': self.name,
6345            'port': self.port,
6346            'remote_identity_group_id': self.remote_identity_group_id,
6347            'remote_identity_healthcheck_username':
6348            self.remote_identity_healthcheck_username,
6349            'secret_store_id': self.secret_store_id,
6350            'tags': self.tags,
6351        }
6352
6353    @classmethod
6354    def from_dict(cls, d):
6355        return cls(
6356            bind_interface=d.get('bind_interface'),
6357            certificate_authority=d.get('certificate_authority'),
6358            client_certificate=d.get('client_certificate'),
6359            client_key=d.get('client_key'),
6360            egress_filter=d.get('egress_filter'),
6361            healthcheck_namespace=d.get('healthcheck_namespace'),
6362            healthy=d.get('healthy'),
6363            hostname=d.get('hostname'),
6364            id=d.get('id'),
6365            name=d.get('name'),
6366            port=d.get('port'),
6367            remote_identity_group_id=d.get('remote_identity_group_id'),
6368            remote_identity_healthcheck_username=d.get(
6369                'remote_identity_healthcheck_username'),
6370            secret_store_id=d.get('secret_store_id'),
6371            tags=d.get('tags'),
6372        )
Kubernetes( bind_interface=None, certificate_authority=None, client_certificate=None, client_key=None, egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, port=None, remote_identity_group_id=None, remote_identity_healthcheck_username=None, secret_store_id=None, tags=None)
6235    def __init__(
6236        self,
6237        bind_interface=None,
6238        certificate_authority=None,
6239        client_certificate=None,
6240        client_key=None,
6241        egress_filter=None,
6242        healthcheck_namespace=None,
6243        healthy=None,
6244        hostname=None,
6245        id=None,
6246        name=None,
6247        port=None,
6248        remote_identity_group_id=None,
6249        remote_identity_healthcheck_username=None,
6250        secret_store_id=None,
6251        tags=None,
6252    ):
6253        self.bind_interface = bind_interface if bind_interface is not None else ''
6254        '''
6255         Bind interface
6256        '''
6257        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
6258        '''
6259
6260        '''
6261        self.client_certificate = client_certificate if client_certificate is not None else ''
6262        '''
6263
6264        '''
6265        self.client_key = client_key if client_key is not None else ''
6266        '''
6267
6268        '''
6269        self.egress_filter = egress_filter if egress_filter is not None else ''
6270        '''
6271         A filter applied to the routing logic to pin datasource to nodes.
6272        '''
6273        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
6274        '''
6275         The path used to check the health of your connection.  Defaults to `default`.
6276        '''
6277        self.healthy = healthy if healthy is not None else False
6278        '''
6279         True if the datasource is reachable and the credentials are valid.
6280        '''
6281        self.hostname = hostname if hostname is not None else ''
6282        '''
6283
6284        '''
6285        self.id = id if id is not None else ''
6286        '''
6287         Unique identifier of the Resource.
6288        '''
6289        self.name = name if name is not None else ''
6290        '''
6291         Unique human-readable name of the Resource.
6292        '''
6293        self.port = port if port is not None else 0
6294        '''
6295
6296        '''
6297        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
6298        '''
6299
6300        '''
6301        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
6302        '''
6303
6304        '''
6305        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6306        '''
6307         ID of the secret store containing credentials for this resource, if any.
6308        '''
6309        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6310        '''
6311         Tags is a map of key, value pairs.
6312        '''
bind_interface

Bind interface

certificate_authority
client_certificate
client_key
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
remote_identity_group_id
remote_identity_healthcheck_username
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
6333    def to_dict(self):
6334        return {
6335            'bind_interface': self.bind_interface,
6336            'certificate_authority': self.certificate_authority,
6337            'client_certificate': self.client_certificate,
6338            'client_key': self.client_key,
6339            'egress_filter': self.egress_filter,
6340            'healthcheck_namespace': self.healthcheck_namespace,
6341            'healthy': self.healthy,
6342            'hostname': self.hostname,
6343            'id': self.id,
6344            'name': self.name,
6345            'port': self.port,
6346            'remote_identity_group_id': self.remote_identity_group_id,
6347            'remote_identity_healthcheck_username':
6348            self.remote_identity_healthcheck_username,
6349            'secret_store_id': self.secret_store_id,
6350            'tags': self.tags,
6351        }
@classmethod
def from_dict(cls, d)
6353    @classmethod
6354    def from_dict(cls, d):
6355        return cls(
6356            bind_interface=d.get('bind_interface'),
6357            certificate_authority=d.get('certificate_authority'),
6358            client_certificate=d.get('client_certificate'),
6359            client_key=d.get('client_key'),
6360            egress_filter=d.get('egress_filter'),
6361            healthcheck_namespace=d.get('healthcheck_namespace'),
6362            healthy=d.get('healthy'),
6363            hostname=d.get('hostname'),
6364            id=d.get('id'),
6365            name=d.get('name'),
6366            port=d.get('port'),
6367            remote_identity_group_id=d.get('remote_identity_group_id'),
6368            remote_identity_healthcheck_username=d.get(
6369                'remote_identity_healthcheck_username'),
6370            secret_store_id=d.get('secret_store_id'),
6371            tags=d.get('tags'),
6372        )
class KubernetesBasicAuth:
6375class KubernetesBasicAuth:
6376    '''
6377
6378    '''
6379    __slots__ = [
6380        'bind_interface',
6381        'egress_filter',
6382        'healthcheck_namespace',
6383        'healthy',
6384        'hostname',
6385        'id',
6386        'name',
6387        'password',
6388        'port',
6389        'secret_store_id',
6390        'tags',
6391        'username',
6392    ]
6393
6394    def __init__(
6395        self,
6396        bind_interface=None,
6397        egress_filter=None,
6398        healthcheck_namespace=None,
6399        healthy=None,
6400        hostname=None,
6401        id=None,
6402        name=None,
6403        password=None,
6404        port=None,
6405        secret_store_id=None,
6406        tags=None,
6407        username=None,
6408    ):
6409        self.bind_interface = bind_interface if bind_interface is not None else ''
6410        '''
6411         Bind interface
6412        '''
6413        self.egress_filter = egress_filter if egress_filter is not None else ''
6414        '''
6415         A filter applied to the routing logic to pin datasource to nodes.
6416        '''
6417        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
6418        '''
6419         The path used to check the health of your connection.  Defaults to `default`.
6420        '''
6421        self.healthy = healthy if healthy is not None else False
6422        '''
6423         True if the datasource is reachable and the credentials are valid.
6424        '''
6425        self.hostname = hostname if hostname is not None else ''
6426        '''
6427
6428        '''
6429        self.id = id if id is not None else ''
6430        '''
6431         Unique identifier of the Resource.
6432        '''
6433        self.name = name if name is not None else ''
6434        '''
6435         Unique human-readable name of the Resource.
6436        '''
6437        self.password = password if password is not None else ''
6438        '''
6439
6440        '''
6441        self.port = port if port is not None else 0
6442        '''
6443
6444        '''
6445        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6446        '''
6447         ID of the secret store containing credentials for this resource, if any.
6448        '''
6449        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6450        '''
6451         Tags is a map of key, value pairs.
6452        '''
6453        self.username = username if username is not None else ''
6454        '''
6455
6456        '''
6457
6458    def __repr__(self):
6459        return '<sdm.KubernetesBasicAuth ' + \
6460            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
6461            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
6462            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
6463            'healthy: ' + repr(self.healthy) + ' ' +\
6464            'hostname: ' + repr(self.hostname) + ' ' +\
6465            'id: ' + repr(self.id) + ' ' +\
6466            'name: ' + repr(self.name) + ' ' +\
6467            'password: ' + repr(self.password) + ' ' +\
6468            'port: ' + repr(self.port) + ' ' +\
6469            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
6470            'tags: ' + repr(self.tags) + ' ' +\
6471            'username: ' + repr(self.username) + ' ' +\
6472            '>'
6473
6474    def to_dict(self):
6475        return {
6476            'bind_interface': self.bind_interface,
6477            'egress_filter': self.egress_filter,
6478            'healthcheck_namespace': self.healthcheck_namespace,
6479            'healthy': self.healthy,
6480            'hostname': self.hostname,
6481            'id': self.id,
6482            'name': self.name,
6483            'password': self.password,
6484            'port': self.port,
6485            'secret_store_id': self.secret_store_id,
6486            'tags': self.tags,
6487            'username': self.username,
6488        }
6489
6490    @classmethod
6491    def from_dict(cls, d):
6492        return cls(
6493            bind_interface=d.get('bind_interface'),
6494            egress_filter=d.get('egress_filter'),
6495            healthcheck_namespace=d.get('healthcheck_namespace'),
6496            healthy=d.get('healthy'),
6497            hostname=d.get('hostname'),
6498            id=d.get('id'),
6499            name=d.get('name'),
6500            password=d.get('password'),
6501            port=d.get('port'),
6502            secret_store_id=d.get('secret_store_id'),
6503            tags=d.get('tags'),
6504            username=d.get('username'),
6505        )
KubernetesBasicAuth( bind_interface=None, egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, secret_store_id=None, tags=None, username=None)
6394    def __init__(
6395        self,
6396        bind_interface=None,
6397        egress_filter=None,
6398        healthcheck_namespace=None,
6399        healthy=None,
6400        hostname=None,
6401        id=None,
6402        name=None,
6403        password=None,
6404        port=None,
6405        secret_store_id=None,
6406        tags=None,
6407        username=None,
6408    ):
6409        self.bind_interface = bind_interface if bind_interface is not None else ''
6410        '''
6411         Bind interface
6412        '''
6413        self.egress_filter = egress_filter if egress_filter is not None else ''
6414        '''
6415         A filter applied to the routing logic to pin datasource to nodes.
6416        '''
6417        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
6418        '''
6419         The path used to check the health of your connection.  Defaults to `default`.
6420        '''
6421        self.healthy = healthy if healthy is not None else False
6422        '''
6423         True if the datasource is reachable and the credentials are valid.
6424        '''
6425        self.hostname = hostname if hostname is not None else ''
6426        '''
6427
6428        '''
6429        self.id = id if id is not None else ''
6430        '''
6431         Unique identifier of the Resource.
6432        '''
6433        self.name = name if name is not None else ''
6434        '''
6435         Unique human-readable name of the Resource.
6436        '''
6437        self.password = password if password is not None else ''
6438        '''
6439
6440        '''
6441        self.port = port if port is not None else 0
6442        '''
6443
6444        '''
6445        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6446        '''
6447         ID of the secret store containing credentials for this resource, if any.
6448        '''
6449        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6450        '''
6451         Tags is a map of key, value pairs.
6452        '''
6453        self.username = username if username is not None else ''
6454        '''
6455
6456        '''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
6474    def to_dict(self):
6475        return {
6476            'bind_interface': self.bind_interface,
6477            'egress_filter': self.egress_filter,
6478            'healthcheck_namespace': self.healthcheck_namespace,
6479            'healthy': self.healthy,
6480            'hostname': self.hostname,
6481            'id': self.id,
6482            'name': self.name,
6483            'password': self.password,
6484            'port': self.port,
6485            'secret_store_id': self.secret_store_id,
6486            'tags': self.tags,
6487            'username': self.username,
6488        }
@classmethod
def from_dict(cls, d)
6490    @classmethod
6491    def from_dict(cls, d):
6492        return cls(
6493            bind_interface=d.get('bind_interface'),
6494            egress_filter=d.get('egress_filter'),
6495            healthcheck_namespace=d.get('healthcheck_namespace'),
6496            healthy=d.get('healthy'),
6497            hostname=d.get('hostname'),
6498            id=d.get('id'),
6499            name=d.get('name'),
6500            password=d.get('password'),
6501            port=d.get('port'),
6502            secret_store_id=d.get('secret_store_id'),
6503            tags=d.get('tags'),
6504            username=d.get('username'),
6505        )
class KubernetesServiceAccount:
6508class KubernetesServiceAccount:
6509    '''
6510
6511    '''
6512    __slots__ = [
6513        'bind_interface',
6514        'egress_filter',
6515        'healthcheck_namespace',
6516        'healthy',
6517        'hostname',
6518        'id',
6519        'name',
6520        'port',
6521        'remote_identity_group_id',
6522        'remote_identity_healthcheck_username',
6523        'secret_store_id',
6524        'tags',
6525        'token',
6526    ]
6527
6528    def __init__(
6529        self,
6530        bind_interface=None,
6531        egress_filter=None,
6532        healthcheck_namespace=None,
6533        healthy=None,
6534        hostname=None,
6535        id=None,
6536        name=None,
6537        port=None,
6538        remote_identity_group_id=None,
6539        remote_identity_healthcheck_username=None,
6540        secret_store_id=None,
6541        tags=None,
6542        token=None,
6543    ):
6544        self.bind_interface = bind_interface if bind_interface is not None else ''
6545        '''
6546         Bind interface
6547        '''
6548        self.egress_filter = egress_filter if egress_filter is not None else ''
6549        '''
6550         A filter applied to the routing logic to pin datasource to nodes.
6551        '''
6552        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
6553        '''
6554         The path used to check the health of your connection.  Defaults to `default`.
6555        '''
6556        self.healthy = healthy if healthy is not None else False
6557        '''
6558         True if the datasource is reachable and the credentials are valid.
6559        '''
6560        self.hostname = hostname if hostname is not None else ''
6561        '''
6562
6563        '''
6564        self.id = id if id is not None else ''
6565        '''
6566         Unique identifier of the Resource.
6567        '''
6568        self.name = name if name is not None else ''
6569        '''
6570         Unique human-readable name of the Resource.
6571        '''
6572        self.port = port if port is not None else 0
6573        '''
6574
6575        '''
6576        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
6577        '''
6578
6579        '''
6580        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
6581        '''
6582
6583        '''
6584        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6585        '''
6586         ID of the secret store containing credentials for this resource, if any.
6587        '''
6588        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6589        '''
6590         Tags is a map of key, value pairs.
6591        '''
6592        self.token = token if token is not None else ''
6593        '''
6594
6595        '''
6596
6597    def __repr__(self):
6598        return '<sdm.KubernetesServiceAccount ' + \
6599            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
6600            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
6601            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
6602            'healthy: ' + repr(self.healthy) + ' ' +\
6603            'hostname: ' + repr(self.hostname) + ' ' +\
6604            'id: ' + repr(self.id) + ' ' +\
6605            'name: ' + repr(self.name) + ' ' +\
6606            'port: ' + repr(self.port) + ' ' +\
6607            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
6608            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
6609            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
6610            'tags: ' + repr(self.tags) + ' ' +\
6611            'token: ' + repr(self.token) + ' ' +\
6612            '>'
6613
6614    def to_dict(self):
6615        return {
6616            'bind_interface': self.bind_interface,
6617            'egress_filter': self.egress_filter,
6618            'healthcheck_namespace': self.healthcheck_namespace,
6619            'healthy': self.healthy,
6620            'hostname': self.hostname,
6621            'id': self.id,
6622            'name': self.name,
6623            'port': self.port,
6624            'remote_identity_group_id': self.remote_identity_group_id,
6625            'remote_identity_healthcheck_username':
6626            self.remote_identity_healthcheck_username,
6627            'secret_store_id': self.secret_store_id,
6628            'tags': self.tags,
6629            'token': self.token,
6630        }
6631
6632    @classmethod
6633    def from_dict(cls, d):
6634        return cls(
6635            bind_interface=d.get('bind_interface'),
6636            egress_filter=d.get('egress_filter'),
6637            healthcheck_namespace=d.get('healthcheck_namespace'),
6638            healthy=d.get('healthy'),
6639            hostname=d.get('hostname'),
6640            id=d.get('id'),
6641            name=d.get('name'),
6642            port=d.get('port'),
6643            remote_identity_group_id=d.get('remote_identity_group_id'),
6644            remote_identity_healthcheck_username=d.get(
6645                'remote_identity_healthcheck_username'),
6646            secret_store_id=d.get('secret_store_id'),
6647            tags=d.get('tags'),
6648            token=d.get('token'),
6649        )
KubernetesServiceAccount( bind_interface=None, egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, port=None, remote_identity_group_id=None, remote_identity_healthcheck_username=None, secret_store_id=None, tags=None, token=None)
6528    def __init__(
6529        self,
6530        bind_interface=None,
6531        egress_filter=None,
6532        healthcheck_namespace=None,
6533        healthy=None,
6534        hostname=None,
6535        id=None,
6536        name=None,
6537        port=None,
6538        remote_identity_group_id=None,
6539        remote_identity_healthcheck_username=None,
6540        secret_store_id=None,
6541        tags=None,
6542        token=None,
6543    ):
6544        self.bind_interface = bind_interface if bind_interface is not None else ''
6545        '''
6546         Bind interface
6547        '''
6548        self.egress_filter = egress_filter if egress_filter is not None else ''
6549        '''
6550         A filter applied to the routing logic to pin datasource to nodes.
6551        '''
6552        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
6553        '''
6554         The path used to check the health of your connection.  Defaults to `default`.
6555        '''
6556        self.healthy = healthy if healthy is not None else False
6557        '''
6558         True if the datasource is reachable and the credentials are valid.
6559        '''
6560        self.hostname = hostname if hostname is not None else ''
6561        '''
6562
6563        '''
6564        self.id = id if id is not None else ''
6565        '''
6566         Unique identifier of the Resource.
6567        '''
6568        self.name = name if name is not None else ''
6569        '''
6570         Unique human-readable name of the Resource.
6571        '''
6572        self.port = port if port is not None else 0
6573        '''
6574
6575        '''
6576        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
6577        '''
6578
6579        '''
6580        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
6581        '''
6582
6583        '''
6584        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6585        '''
6586         ID of the secret store containing credentials for this resource, if any.
6587        '''
6588        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6589        '''
6590         Tags is a map of key, value pairs.
6591        '''
6592        self.token = token if token is not None else ''
6593        '''
6594
6595        '''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
remote_identity_group_id
remote_identity_healthcheck_username
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

token
def to_dict(self)
6614    def to_dict(self):
6615        return {
6616            'bind_interface': self.bind_interface,
6617            'egress_filter': self.egress_filter,
6618            'healthcheck_namespace': self.healthcheck_namespace,
6619            'healthy': self.healthy,
6620            'hostname': self.hostname,
6621            'id': self.id,
6622            'name': self.name,
6623            'port': self.port,
6624            'remote_identity_group_id': self.remote_identity_group_id,
6625            'remote_identity_healthcheck_username':
6626            self.remote_identity_healthcheck_username,
6627            'secret_store_id': self.secret_store_id,
6628            'tags': self.tags,
6629            'token': self.token,
6630        }
@classmethod
def from_dict(cls, d)
6632    @classmethod
6633    def from_dict(cls, d):
6634        return cls(
6635            bind_interface=d.get('bind_interface'),
6636            egress_filter=d.get('egress_filter'),
6637            healthcheck_namespace=d.get('healthcheck_namespace'),
6638            healthy=d.get('healthy'),
6639            hostname=d.get('hostname'),
6640            id=d.get('id'),
6641            name=d.get('name'),
6642            port=d.get('port'),
6643            remote_identity_group_id=d.get('remote_identity_group_id'),
6644            remote_identity_healthcheck_username=d.get(
6645                'remote_identity_healthcheck_username'),
6646            secret_store_id=d.get('secret_store_id'),
6647            tags=d.get('tags'),
6648            token=d.get('token'),
6649        )
class KubernetesServiceAccountUserImpersonation:
6652class KubernetesServiceAccountUserImpersonation:
6653    '''
6654
6655    '''
6656    __slots__ = [
6657        'bind_interface',
6658        'egress_filter',
6659        'healthcheck_namespace',
6660        'healthy',
6661        'hostname',
6662        'id',
6663        'name',
6664        'port',
6665        'secret_store_id',
6666        'tags',
6667        'token',
6668    ]
6669
6670    def __init__(
6671        self,
6672        bind_interface=None,
6673        egress_filter=None,
6674        healthcheck_namespace=None,
6675        healthy=None,
6676        hostname=None,
6677        id=None,
6678        name=None,
6679        port=None,
6680        secret_store_id=None,
6681        tags=None,
6682        token=None,
6683    ):
6684        self.bind_interface = bind_interface if bind_interface is not None else ''
6685        '''
6686         Bind interface
6687        '''
6688        self.egress_filter = egress_filter if egress_filter is not None else ''
6689        '''
6690         A filter applied to the routing logic to pin datasource to nodes.
6691        '''
6692        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
6693        '''
6694         The path used to check the health of your connection.  Defaults to `default`.
6695        '''
6696        self.healthy = healthy if healthy is not None else False
6697        '''
6698         True if the datasource is reachable and the credentials are valid.
6699        '''
6700        self.hostname = hostname if hostname is not None else ''
6701        '''
6702
6703        '''
6704        self.id = id if id is not None else ''
6705        '''
6706         Unique identifier of the Resource.
6707        '''
6708        self.name = name if name is not None else ''
6709        '''
6710         Unique human-readable name of the Resource.
6711        '''
6712        self.port = port if port is not None else 0
6713        '''
6714
6715        '''
6716        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6717        '''
6718         ID of the secret store containing credentials for this resource, if any.
6719        '''
6720        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6721        '''
6722         Tags is a map of key, value pairs.
6723        '''
6724        self.token = token if token is not None else ''
6725        '''
6726
6727        '''
6728
6729    def __repr__(self):
6730        return '<sdm.KubernetesServiceAccountUserImpersonation ' + \
6731            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
6732            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
6733            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
6734            'healthy: ' + repr(self.healthy) + ' ' +\
6735            'hostname: ' + repr(self.hostname) + ' ' +\
6736            'id: ' + repr(self.id) + ' ' +\
6737            'name: ' + repr(self.name) + ' ' +\
6738            'port: ' + repr(self.port) + ' ' +\
6739            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
6740            'tags: ' + repr(self.tags) + ' ' +\
6741            'token: ' + repr(self.token) + ' ' +\
6742            '>'
6743
6744    def to_dict(self):
6745        return {
6746            'bind_interface': self.bind_interface,
6747            'egress_filter': self.egress_filter,
6748            'healthcheck_namespace': self.healthcheck_namespace,
6749            'healthy': self.healthy,
6750            'hostname': self.hostname,
6751            'id': self.id,
6752            'name': self.name,
6753            'port': self.port,
6754            'secret_store_id': self.secret_store_id,
6755            'tags': self.tags,
6756            'token': self.token,
6757        }
6758
6759    @classmethod
6760    def from_dict(cls, d):
6761        return cls(
6762            bind_interface=d.get('bind_interface'),
6763            egress_filter=d.get('egress_filter'),
6764            healthcheck_namespace=d.get('healthcheck_namespace'),
6765            healthy=d.get('healthy'),
6766            hostname=d.get('hostname'),
6767            id=d.get('id'),
6768            name=d.get('name'),
6769            port=d.get('port'),
6770            secret_store_id=d.get('secret_store_id'),
6771            tags=d.get('tags'),
6772            token=d.get('token'),
6773        )
KubernetesServiceAccountUserImpersonation( bind_interface=None, egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, port=None, secret_store_id=None, tags=None, token=None)
6670    def __init__(
6671        self,
6672        bind_interface=None,
6673        egress_filter=None,
6674        healthcheck_namespace=None,
6675        healthy=None,
6676        hostname=None,
6677        id=None,
6678        name=None,
6679        port=None,
6680        secret_store_id=None,
6681        tags=None,
6682        token=None,
6683    ):
6684        self.bind_interface = bind_interface if bind_interface is not None else ''
6685        '''
6686         Bind interface
6687        '''
6688        self.egress_filter = egress_filter if egress_filter is not None else ''
6689        '''
6690         A filter applied to the routing logic to pin datasource to nodes.
6691        '''
6692        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
6693        '''
6694         The path used to check the health of your connection.  Defaults to `default`.
6695        '''
6696        self.healthy = healthy if healthy is not None else False
6697        '''
6698         True if the datasource is reachable and the credentials are valid.
6699        '''
6700        self.hostname = hostname if hostname is not None else ''
6701        '''
6702
6703        '''
6704        self.id = id if id is not None else ''
6705        '''
6706         Unique identifier of the Resource.
6707        '''
6708        self.name = name if name is not None else ''
6709        '''
6710         Unique human-readable name of the Resource.
6711        '''
6712        self.port = port if port is not None else 0
6713        '''
6714
6715        '''
6716        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6717        '''
6718         ID of the secret store containing credentials for this resource, if any.
6719        '''
6720        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6721        '''
6722         Tags is a map of key, value pairs.
6723        '''
6724        self.token = token if token is not None else ''
6725        '''
6726
6727        '''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

token
def to_dict(self)
6744    def to_dict(self):
6745        return {
6746            'bind_interface': self.bind_interface,
6747            'egress_filter': self.egress_filter,
6748            'healthcheck_namespace': self.healthcheck_namespace,
6749            'healthy': self.healthy,
6750            'hostname': self.hostname,
6751            'id': self.id,
6752            'name': self.name,
6753            'port': self.port,
6754            'secret_store_id': self.secret_store_id,
6755            'tags': self.tags,
6756            'token': self.token,
6757        }
@classmethod
def from_dict(cls, d)
6759    @classmethod
6760    def from_dict(cls, d):
6761        return cls(
6762            bind_interface=d.get('bind_interface'),
6763            egress_filter=d.get('egress_filter'),
6764            healthcheck_namespace=d.get('healthcheck_namespace'),
6765            healthy=d.get('healthy'),
6766            hostname=d.get('hostname'),
6767            id=d.get('id'),
6768            name=d.get('name'),
6769            port=d.get('port'),
6770            secret_store_id=d.get('secret_store_id'),
6771            tags=d.get('tags'),
6772            token=d.get('token'),
6773        )
class KubernetesUserImpersonation:
6776class KubernetesUserImpersonation:
6777    '''
6778
6779    '''
6780    __slots__ = [
6781        'bind_interface',
6782        'certificate_authority',
6783        'client_certificate',
6784        'client_key',
6785        'egress_filter',
6786        'healthcheck_namespace',
6787        'healthy',
6788        'hostname',
6789        'id',
6790        'name',
6791        'port',
6792        'secret_store_id',
6793        'tags',
6794    ]
6795
6796    def __init__(
6797        self,
6798        bind_interface=None,
6799        certificate_authority=None,
6800        client_certificate=None,
6801        client_key=None,
6802        egress_filter=None,
6803        healthcheck_namespace=None,
6804        healthy=None,
6805        hostname=None,
6806        id=None,
6807        name=None,
6808        port=None,
6809        secret_store_id=None,
6810        tags=None,
6811    ):
6812        self.bind_interface = bind_interface if bind_interface is not None else ''
6813        '''
6814         Bind interface
6815        '''
6816        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
6817        '''
6818
6819        '''
6820        self.client_certificate = client_certificate if client_certificate is not None else ''
6821        '''
6822
6823        '''
6824        self.client_key = client_key if client_key is not None else ''
6825        '''
6826
6827        '''
6828        self.egress_filter = egress_filter if egress_filter is not None else ''
6829        '''
6830         A filter applied to the routing logic to pin datasource to nodes.
6831        '''
6832        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
6833        '''
6834         The path used to check the health of your connection.  Defaults to `default`.
6835        '''
6836        self.healthy = healthy if healthy is not None else False
6837        '''
6838         True if the datasource is reachable and the credentials are valid.
6839        '''
6840        self.hostname = hostname if hostname is not None else ''
6841        '''
6842
6843        '''
6844        self.id = id if id is not None else ''
6845        '''
6846         Unique identifier of the Resource.
6847        '''
6848        self.name = name if name is not None else ''
6849        '''
6850         Unique human-readable name of the Resource.
6851        '''
6852        self.port = port if port is not None else 0
6853        '''
6854
6855        '''
6856        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6857        '''
6858         ID of the secret store containing credentials for this resource, if any.
6859        '''
6860        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6861        '''
6862         Tags is a map of key, value pairs.
6863        '''
6864
6865    def __repr__(self):
6866        return '<sdm.KubernetesUserImpersonation ' + \
6867            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
6868            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
6869            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
6870            'client_key: ' + repr(self.client_key) + ' ' +\
6871            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
6872            'healthcheck_namespace: ' + repr(self.healthcheck_namespace) + ' ' +\
6873            'healthy: ' + repr(self.healthy) + ' ' +\
6874            'hostname: ' + repr(self.hostname) + ' ' +\
6875            'id: ' + repr(self.id) + ' ' +\
6876            'name: ' + repr(self.name) + ' ' +\
6877            'port: ' + repr(self.port) + ' ' +\
6878            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
6879            'tags: ' + repr(self.tags) + ' ' +\
6880            '>'
6881
6882    def to_dict(self):
6883        return {
6884            'bind_interface': self.bind_interface,
6885            'certificate_authority': self.certificate_authority,
6886            'client_certificate': self.client_certificate,
6887            'client_key': self.client_key,
6888            'egress_filter': self.egress_filter,
6889            'healthcheck_namespace': self.healthcheck_namespace,
6890            'healthy': self.healthy,
6891            'hostname': self.hostname,
6892            'id': self.id,
6893            'name': self.name,
6894            'port': self.port,
6895            'secret_store_id': self.secret_store_id,
6896            'tags': self.tags,
6897        }
6898
6899    @classmethod
6900    def from_dict(cls, d):
6901        return cls(
6902            bind_interface=d.get('bind_interface'),
6903            certificate_authority=d.get('certificate_authority'),
6904            client_certificate=d.get('client_certificate'),
6905            client_key=d.get('client_key'),
6906            egress_filter=d.get('egress_filter'),
6907            healthcheck_namespace=d.get('healthcheck_namespace'),
6908            healthy=d.get('healthy'),
6909            hostname=d.get('hostname'),
6910            id=d.get('id'),
6911            name=d.get('name'),
6912            port=d.get('port'),
6913            secret_store_id=d.get('secret_store_id'),
6914            tags=d.get('tags'),
6915        )
KubernetesUserImpersonation( bind_interface=None, certificate_authority=None, client_certificate=None, client_key=None, egress_filter=None, healthcheck_namespace=None, healthy=None, hostname=None, id=None, name=None, port=None, secret_store_id=None, tags=None)
6796    def __init__(
6797        self,
6798        bind_interface=None,
6799        certificate_authority=None,
6800        client_certificate=None,
6801        client_key=None,
6802        egress_filter=None,
6803        healthcheck_namespace=None,
6804        healthy=None,
6805        hostname=None,
6806        id=None,
6807        name=None,
6808        port=None,
6809        secret_store_id=None,
6810        tags=None,
6811    ):
6812        self.bind_interface = bind_interface if bind_interface is not None else ''
6813        '''
6814         Bind interface
6815        '''
6816        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
6817        '''
6818
6819        '''
6820        self.client_certificate = client_certificate if client_certificate is not None else ''
6821        '''
6822
6823        '''
6824        self.client_key = client_key if client_key is not None else ''
6825        '''
6826
6827        '''
6828        self.egress_filter = egress_filter if egress_filter is not None else ''
6829        '''
6830         A filter applied to the routing logic to pin datasource to nodes.
6831        '''
6832        self.healthcheck_namespace = healthcheck_namespace if healthcheck_namespace is not None else ''
6833        '''
6834         The path used to check the health of your connection.  Defaults to `default`.
6835        '''
6836        self.healthy = healthy if healthy is not None else False
6837        '''
6838         True if the datasource is reachable and the credentials are valid.
6839        '''
6840        self.hostname = hostname if hostname is not None else ''
6841        '''
6842
6843        '''
6844        self.id = id if id is not None else ''
6845        '''
6846         Unique identifier of the Resource.
6847        '''
6848        self.name = name if name is not None else ''
6849        '''
6850         Unique human-readable name of the Resource.
6851        '''
6852        self.port = port if port is not None else 0
6853        '''
6854
6855        '''
6856        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
6857        '''
6858         ID of the secret store containing credentials for this resource, if any.
6859        '''
6860        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
6861        '''
6862         Tags is a map of key, value pairs.
6863        '''
bind_interface

Bind interface

certificate_authority
client_certificate
client_key
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthcheck_namespace

The path used to check the health of your connection. Defaults to default.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
6882    def to_dict(self):
6883        return {
6884            'bind_interface': self.bind_interface,
6885            'certificate_authority': self.certificate_authority,
6886            'client_certificate': self.client_certificate,
6887            'client_key': self.client_key,
6888            'egress_filter': self.egress_filter,
6889            'healthcheck_namespace': self.healthcheck_namespace,
6890            'healthy': self.healthy,
6891            'hostname': self.hostname,
6892            'id': self.id,
6893            'name': self.name,
6894            'port': self.port,
6895            'secret_store_id': self.secret_store_id,
6896            'tags': self.tags,
6897        }
@classmethod
def from_dict(cls, d)
6899    @classmethod
6900    def from_dict(cls, d):
6901        return cls(
6902            bind_interface=d.get('bind_interface'),
6903            certificate_authority=d.get('certificate_authority'),
6904            client_certificate=d.get('client_certificate'),
6905            client_key=d.get('client_key'),
6906            egress_filter=d.get('egress_filter'),
6907            healthcheck_namespace=d.get('healthcheck_namespace'),
6908            healthy=d.get('healthy'),
6909            hostname=d.get('hostname'),
6910            id=d.get('id'),
6911            name=d.get('name'),
6912            port=d.get('port'),
6913            secret_store_id=d.get('secret_store_id'),
6914            tags=d.get('tags'),
6915        )
class MTLSMysql:
6918class MTLSMysql:
6919    '''
6920
6921    '''
6922    __slots__ = [
6923        'bind_interface',
6924        'certificate_authority',
6925        'client_certificate',
6926        'client_key',
6927        'database',
6928        'egress_filter',
6929        'healthy',
6930        'hostname',
6931        'id',
6932        'name',
6933        'password',
6934        'port',
6935        'port_override',
6936        'secret_store_id',
6937        'server_name',
6938        'tags',
6939        'username',
6940    ]
6941
6942    def __init__(
6943        self,
6944        bind_interface=None,
6945        certificate_authority=None,
6946        client_certificate=None,
6947        client_key=None,
6948        database=None,
6949        egress_filter=None,
6950        healthy=None,
6951        hostname=None,
6952        id=None,
6953        name=None,
6954        password=None,
6955        port=None,
6956        port_override=None,
6957        secret_store_id=None,
6958        server_name=None,
6959        tags=None,
6960        username=None,
6961    ):
6962        self.bind_interface = bind_interface if bind_interface is not None else ''
6963        '''
6964         Bind interface
6965        '''
6966        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
6967        '''
6968
6969        '''
6970        self.client_certificate = client_certificate if client_certificate is not None else ''
6971        '''
6972
6973        '''
6974        self.client_key = client_key if client_key is not None else ''
6975        '''
6976
6977        '''
6978        self.database = database if database is not None else ''
6979        '''
6980
6981        '''
6982        self.egress_filter = egress_filter if egress_filter is not None else ''
6983        '''
6984         A filter applied to the routing logic to pin datasource to nodes.
6985        '''
6986        self.healthy = healthy if healthy is not None else False
6987        '''
6988         True if the datasource is reachable and the credentials are valid.
6989        '''
6990        self.hostname = hostname if hostname is not None else ''
6991        '''
6992
6993        '''
6994        self.id = id if id is not None else ''
6995        '''
6996         Unique identifier of the Resource.
6997        '''
6998        self.name = name if name is not None else ''
6999        '''
7000         Unique human-readable name of the Resource.
7001        '''
7002        self.password = password if password is not None else ''
7003        '''
7004
7005        '''
7006        self.port = port if port is not None else 0
7007        '''
7008
7009        '''
7010        self.port_override = port_override if port_override is not None else 0
7011        '''
7012
7013        '''
7014        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7015        '''
7016         ID of the secret store containing credentials for this resource, if any.
7017        '''
7018        self.server_name = server_name if server_name is not None else ''
7019        '''
7020
7021        '''
7022        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7023        '''
7024         Tags is a map of key, value pairs.
7025        '''
7026        self.username = username if username is not None else ''
7027        '''
7028
7029        '''
7030
7031    def __repr__(self):
7032        return '<sdm.MTLSMysql ' + \
7033            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
7034            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
7035            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
7036            'client_key: ' + repr(self.client_key) + ' ' +\
7037            'database: ' + repr(self.database) + ' ' +\
7038            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
7039            'healthy: ' + repr(self.healthy) + ' ' +\
7040            'hostname: ' + repr(self.hostname) + ' ' +\
7041            'id: ' + repr(self.id) + ' ' +\
7042            'name: ' + repr(self.name) + ' ' +\
7043            'password: ' + repr(self.password) + ' ' +\
7044            'port: ' + repr(self.port) + ' ' +\
7045            'port_override: ' + repr(self.port_override) + ' ' +\
7046            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
7047            'server_name: ' + repr(self.server_name) + ' ' +\
7048            'tags: ' + repr(self.tags) + ' ' +\
7049            'username: ' + repr(self.username) + ' ' +\
7050            '>'
7051
7052    def to_dict(self):
7053        return {
7054            'bind_interface': self.bind_interface,
7055            'certificate_authority': self.certificate_authority,
7056            'client_certificate': self.client_certificate,
7057            'client_key': self.client_key,
7058            'database': self.database,
7059            'egress_filter': self.egress_filter,
7060            'healthy': self.healthy,
7061            'hostname': self.hostname,
7062            'id': self.id,
7063            'name': self.name,
7064            'password': self.password,
7065            'port': self.port,
7066            'port_override': self.port_override,
7067            'secret_store_id': self.secret_store_id,
7068            'server_name': self.server_name,
7069            'tags': self.tags,
7070            'username': self.username,
7071        }
7072
7073    @classmethod
7074    def from_dict(cls, d):
7075        return cls(
7076            bind_interface=d.get('bind_interface'),
7077            certificate_authority=d.get('certificate_authority'),
7078            client_certificate=d.get('client_certificate'),
7079            client_key=d.get('client_key'),
7080            database=d.get('database'),
7081            egress_filter=d.get('egress_filter'),
7082            healthy=d.get('healthy'),
7083            hostname=d.get('hostname'),
7084            id=d.get('id'),
7085            name=d.get('name'),
7086            password=d.get('password'),
7087            port=d.get('port'),
7088            port_override=d.get('port_override'),
7089            secret_store_id=d.get('secret_store_id'),
7090            server_name=d.get('server_name'),
7091            tags=d.get('tags'),
7092            username=d.get('username'),
7093        )
MTLSMysql( bind_interface=None, certificate_authority=None, client_certificate=None, client_key=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, server_name=None, tags=None, username=None)
6942    def __init__(
6943        self,
6944        bind_interface=None,
6945        certificate_authority=None,
6946        client_certificate=None,
6947        client_key=None,
6948        database=None,
6949        egress_filter=None,
6950        healthy=None,
6951        hostname=None,
6952        id=None,
6953        name=None,
6954        password=None,
6955        port=None,
6956        port_override=None,
6957        secret_store_id=None,
6958        server_name=None,
6959        tags=None,
6960        username=None,
6961    ):
6962        self.bind_interface = bind_interface if bind_interface is not None else ''
6963        '''
6964         Bind interface
6965        '''
6966        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
6967        '''
6968
6969        '''
6970        self.client_certificate = client_certificate if client_certificate is not None else ''
6971        '''
6972
6973        '''
6974        self.client_key = client_key if client_key is not None else ''
6975        '''
6976
6977        '''
6978        self.database = database if database is not None else ''
6979        '''
6980
6981        '''
6982        self.egress_filter = egress_filter if egress_filter is not None else ''
6983        '''
6984         A filter applied to the routing logic to pin datasource to nodes.
6985        '''
6986        self.healthy = healthy if healthy is not None else False
6987        '''
6988         True if the datasource is reachable and the credentials are valid.
6989        '''
6990        self.hostname = hostname if hostname is not None else ''
6991        '''
6992
6993        '''
6994        self.id = id if id is not None else ''
6995        '''
6996         Unique identifier of the Resource.
6997        '''
6998        self.name = name if name is not None else ''
6999        '''
7000         Unique human-readable name of the Resource.
7001        '''
7002        self.password = password if password is not None else ''
7003        '''
7004
7005        '''
7006        self.port = port if port is not None else 0
7007        '''
7008
7009        '''
7010        self.port_override = port_override if port_override is not None else 0
7011        '''
7012
7013        '''
7014        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7015        '''
7016         ID of the secret store containing credentials for this resource, if any.
7017        '''
7018        self.server_name = server_name if server_name is not None else ''
7019        '''
7020
7021        '''
7022        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7023        '''
7024         Tags is a map of key, value pairs.
7025        '''
7026        self.username = username if username is not None else ''
7027        '''
7028
7029        '''
bind_interface

Bind interface

certificate_authority
client_certificate
client_key
database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

server_name
tags

Tags is a map of key, value pairs.

username
def to_dict(self)
7052    def to_dict(self):
7053        return {
7054            'bind_interface': self.bind_interface,
7055            'certificate_authority': self.certificate_authority,
7056            'client_certificate': self.client_certificate,
7057            'client_key': self.client_key,
7058            'database': self.database,
7059            'egress_filter': self.egress_filter,
7060            'healthy': self.healthy,
7061            'hostname': self.hostname,
7062            'id': self.id,
7063            'name': self.name,
7064            'password': self.password,
7065            'port': self.port,
7066            'port_override': self.port_override,
7067            'secret_store_id': self.secret_store_id,
7068            'server_name': self.server_name,
7069            'tags': self.tags,
7070            'username': self.username,
7071        }
@classmethod
def from_dict(cls, d)
7073    @classmethod
7074    def from_dict(cls, d):
7075        return cls(
7076            bind_interface=d.get('bind_interface'),
7077            certificate_authority=d.get('certificate_authority'),
7078            client_certificate=d.get('client_certificate'),
7079            client_key=d.get('client_key'),
7080            database=d.get('database'),
7081            egress_filter=d.get('egress_filter'),
7082            healthy=d.get('healthy'),
7083            hostname=d.get('hostname'),
7084            id=d.get('id'),
7085            name=d.get('name'),
7086            password=d.get('password'),
7087            port=d.get('port'),
7088            port_override=d.get('port_override'),
7089            secret_store_id=d.get('secret_store_id'),
7090            server_name=d.get('server_name'),
7091            tags=d.get('tags'),
7092            username=d.get('username'),
7093        )
class MTLSPostgres:
7096class MTLSPostgres:
7097    '''
7098
7099    '''
7100    __slots__ = [
7101        'bind_interface',
7102        'certificate_authority',
7103        'client_certificate',
7104        'client_key',
7105        'database',
7106        'egress_filter',
7107        'healthy',
7108        'hostname',
7109        'id',
7110        'name',
7111        'override_database',
7112        'password',
7113        'port',
7114        'port_override',
7115        'secret_store_id',
7116        'server_name',
7117        'tags',
7118        'username',
7119    ]
7120
7121    def __init__(
7122        self,
7123        bind_interface=None,
7124        certificate_authority=None,
7125        client_certificate=None,
7126        client_key=None,
7127        database=None,
7128        egress_filter=None,
7129        healthy=None,
7130        hostname=None,
7131        id=None,
7132        name=None,
7133        override_database=None,
7134        password=None,
7135        port=None,
7136        port_override=None,
7137        secret_store_id=None,
7138        server_name=None,
7139        tags=None,
7140        username=None,
7141    ):
7142        self.bind_interface = bind_interface if bind_interface is not None else ''
7143        '''
7144         Bind interface
7145        '''
7146        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
7147        '''
7148
7149        '''
7150        self.client_certificate = client_certificate if client_certificate is not None else ''
7151        '''
7152
7153        '''
7154        self.client_key = client_key if client_key is not None else ''
7155        '''
7156
7157        '''
7158        self.database = database if database is not None else ''
7159        '''
7160
7161        '''
7162        self.egress_filter = egress_filter if egress_filter is not None else ''
7163        '''
7164         A filter applied to the routing logic to pin datasource to nodes.
7165        '''
7166        self.healthy = healthy if healthy is not None else False
7167        '''
7168         True if the datasource is reachable and the credentials are valid.
7169        '''
7170        self.hostname = hostname if hostname is not None else ''
7171        '''
7172
7173        '''
7174        self.id = id if id is not None else ''
7175        '''
7176         Unique identifier of the Resource.
7177        '''
7178        self.name = name if name is not None else ''
7179        '''
7180         Unique human-readable name of the Resource.
7181        '''
7182        self.override_database = override_database if override_database is not None else False
7183        '''
7184
7185        '''
7186        self.password = password if password is not None else ''
7187        '''
7188
7189        '''
7190        self.port = port if port is not None else 0
7191        '''
7192
7193        '''
7194        self.port_override = port_override if port_override is not None else 0
7195        '''
7196
7197        '''
7198        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7199        '''
7200         ID of the secret store containing credentials for this resource, if any.
7201        '''
7202        self.server_name = server_name if server_name is not None else ''
7203        '''
7204
7205        '''
7206        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7207        '''
7208         Tags is a map of key, value pairs.
7209        '''
7210        self.username = username if username is not None else ''
7211        '''
7212
7213        '''
7214
7215    def __repr__(self):
7216        return '<sdm.MTLSPostgres ' + \
7217            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
7218            'certificate_authority: ' + repr(self.certificate_authority) + ' ' +\
7219            'client_certificate: ' + repr(self.client_certificate) + ' ' +\
7220            'client_key: ' + repr(self.client_key) + ' ' +\
7221            'database: ' + repr(self.database) + ' ' +\
7222            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
7223            'healthy: ' + repr(self.healthy) + ' ' +\
7224            'hostname: ' + repr(self.hostname) + ' ' +\
7225            'id: ' + repr(self.id) + ' ' +\
7226            'name: ' + repr(self.name) + ' ' +\
7227            'override_database: ' + repr(self.override_database) + ' ' +\
7228            'password: ' + repr(self.password) + ' ' +\
7229            'port: ' + repr(self.port) + ' ' +\
7230            'port_override: ' + repr(self.port_override) + ' ' +\
7231            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
7232            'server_name: ' + repr(self.server_name) + ' ' +\
7233            'tags: ' + repr(self.tags) + ' ' +\
7234            'username: ' + repr(self.username) + ' ' +\
7235            '>'
7236
7237    def to_dict(self):
7238        return {
7239            'bind_interface': self.bind_interface,
7240            'certificate_authority': self.certificate_authority,
7241            'client_certificate': self.client_certificate,
7242            'client_key': self.client_key,
7243            'database': self.database,
7244            'egress_filter': self.egress_filter,
7245            'healthy': self.healthy,
7246            'hostname': self.hostname,
7247            'id': self.id,
7248            'name': self.name,
7249            'override_database': self.override_database,
7250            'password': self.password,
7251            'port': self.port,
7252            'port_override': self.port_override,
7253            'secret_store_id': self.secret_store_id,
7254            'server_name': self.server_name,
7255            'tags': self.tags,
7256            'username': self.username,
7257        }
7258
7259    @classmethod
7260    def from_dict(cls, d):
7261        return cls(
7262            bind_interface=d.get('bind_interface'),
7263            certificate_authority=d.get('certificate_authority'),
7264            client_certificate=d.get('client_certificate'),
7265            client_key=d.get('client_key'),
7266            database=d.get('database'),
7267            egress_filter=d.get('egress_filter'),
7268            healthy=d.get('healthy'),
7269            hostname=d.get('hostname'),
7270            id=d.get('id'),
7271            name=d.get('name'),
7272            override_database=d.get('override_database'),
7273            password=d.get('password'),
7274            port=d.get('port'),
7275            port_override=d.get('port_override'),
7276            secret_store_id=d.get('secret_store_id'),
7277            server_name=d.get('server_name'),
7278            tags=d.get('tags'),
7279            username=d.get('username'),
7280        )
MTLSPostgres( bind_interface=None, certificate_authority=None, client_certificate=None, client_key=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, override_database=None, password=None, port=None, port_override=None, secret_store_id=None, server_name=None, tags=None, username=None)
7121    def __init__(
7122        self,
7123        bind_interface=None,
7124        certificate_authority=None,
7125        client_certificate=None,
7126        client_key=None,
7127        database=None,
7128        egress_filter=None,
7129        healthy=None,
7130        hostname=None,
7131        id=None,
7132        name=None,
7133        override_database=None,
7134        password=None,
7135        port=None,
7136        port_override=None,
7137        secret_store_id=None,
7138        server_name=None,
7139        tags=None,
7140        username=None,
7141    ):
7142        self.bind_interface = bind_interface if bind_interface is not None else ''
7143        '''
7144         Bind interface
7145        '''
7146        self.certificate_authority = certificate_authority if certificate_authority is not None else ''
7147        '''
7148
7149        '''
7150        self.client_certificate = client_certificate if client_certificate is not None else ''
7151        '''
7152
7153        '''
7154        self.client_key = client_key if client_key is not None else ''
7155        '''
7156
7157        '''
7158        self.database = database if database is not None else ''
7159        '''
7160
7161        '''
7162        self.egress_filter = egress_filter if egress_filter is not None else ''
7163        '''
7164         A filter applied to the routing logic to pin datasource to nodes.
7165        '''
7166        self.healthy = healthy if healthy is not None else False
7167        '''
7168         True if the datasource is reachable and the credentials are valid.
7169        '''
7170        self.hostname = hostname if hostname is not None else ''
7171        '''
7172
7173        '''
7174        self.id = id if id is not None else ''
7175        '''
7176         Unique identifier of the Resource.
7177        '''
7178        self.name = name if name is not None else ''
7179        '''
7180         Unique human-readable name of the Resource.
7181        '''
7182        self.override_database = override_database if override_database is not None else False
7183        '''
7184
7185        '''
7186        self.password = password if password is not None else ''
7187        '''
7188
7189        '''
7190        self.port = port if port is not None else 0
7191        '''
7192
7193        '''
7194        self.port_override = port_override if port_override is not None else 0
7195        '''
7196
7197        '''
7198        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7199        '''
7200         ID of the secret store containing credentials for this resource, if any.
7201        '''
7202        self.server_name = server_name if server_name is not None else ''
7203        '''
7204
7205        '''
7206        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7207        '''
7208         Tags is a map of key, value pairs.
7209        '''
7210        self.username = username if username is not None else ''
7211        '''
7212
7213        '''
bind_interface

Bind interface

certificate_authority
client_certificate
client_key
database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

override_database
password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

server_name
tags

Tags is a map of key, value pairs.

username
def to_dict(self)
7237    def to_dict(self):
7238        return {
7239            'bind_interface': self.bind_interface,
7240            'certificate_authority': self.certificate_authority,
7241            'client_certificate': self.client_certificate,
7242            'client_key': self.client_key,
7243            'database': self.database,
7244            'egress_filter': self.egress_filter,
7245            'healthy': self.healthy,
7246            'hostname': self.hostname,
7247            'id': self.id,
7248            'name': self.name,
7249            'override_database': self.override_database,
7250            'password': self.password,
7251            'port': self.port,
7252            'port_override': self.port_override,
7253            'secret_store_id': self.secret_store_id,
7254            'server_name': self.server_name,
7255            'tags': self.tags,
7256            'username': self.username,
7257        }
@classmethod
def from_dict(cls, d)
7259    @classmethod
7260    def from_dict(cls, d):
7261        return cls(
7262            bind_interface=d.get('bind_interface'),
7263            certificate_authority=d.get('certificate_authority'),
7264            client_certificate=d.get('client_certificate'),
7265            client_key=d.get('client_key'),
7266            database=d.get('database'),
7267            egress_filter=d.get('egress_filter'),
7268            healthy=d.get('healthy'),
7269            hostname=d.get('hostname'),
7270            id=d.get('id'),
7271            name=d.get('name'),
7272            override_database=d.get('override_database'),
7273            password=d.get('password'),
7274            port=d.get('port'),
7275            port_override=d.get('port_override'),
7276            secret_store_id=d.get('secret_store_id'),
7277            server_name=d.get('server_name'),
7278            tags=d.get('tags'),
7279            username=d.get('username'),
7280        )
class Maria:
7283class Maria:
7284    '''
7285
7286    '''
7287    __slots__ = [
7288        'bind_interface',
7289        'database',
7290        'egress_filter',
7291        'healthy',
7292        'hostname',
7293        'id',
7294        'name',
7295        'password',
7296        'port',
7297        'port_override',
7298        'secret_store_id',
7299        'tags',
7300        'username',
7301    ]
7302
7303    def __init__(
7304        self,
7305        bind_interface=None,
7306        database=None,
7307        egress_filter=None,
7308        healthy=None,
7309        hostname=None,
7310        id=None,
7311        name=None,
7312        password=None,
7313        port=None,
7314        port_override=None,
7315        secret_store_id=None,
7316        tags=None,
7317        username=None,
7318    ):
7319        self.bind_interface = bind_interface if bind_interface is not None else ''
7320        '''
7321         Bind interface
7322        '''
7323        self.database = database if database is not None else ''
7324        '''
7325
7326        '''
7327        self.egress_filter = egress_filter if egress_filter is not None else ''
7328        '''
7329         A filter applied to the routing logic to pin datasource to nodes.
7330        '''
7331        self.healthy = healthy if healthy is not None else False
7332        '''
7333         True if the datasource is reachable and the credentials are valid.
7334        '''
7335        self.hostname = hostname if hostname is not None else ''
7336        '''
7337
7338        '''
7339        self.id = id if id is not None else ''
7340        '''
7341         Unique identifier of the Resource.
7342        '''
7343        self.name = name if name is not None else ''
7344        '''
7345         Unique human-readable name of the Resource.
7346        '''
7347        self.password = password if password is not None else ''
7348        '''
7349
7350        '''
7351        self.port = port if port is not None else 0
7352        '''
7353
7354        '''
7355        self.port_override = port_override if port_override is not None else 0
7356        '''
7357
7358        '''
7359        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7360        '''
7361         ID of the secret store containing credentials for this resource, if any.
7362        '''
7363        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7364        '''
7365         Tags is a map of key, value pairs.
7366        '''
7367        self.username = username if username is not None else ''
7368        '''
7369
7370        '''
7371
7372    def __repr__(self):
7373        return '<sdm.Maria ' + \
7374            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
7375            'database: ' + repr(self.database) + ' ' +\
7376            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
7377            'healthy: ' + repr(self.healthy) + ' ' +\
7378            'hostname: ' + repr(self.hostname) + ' ' +\
7379            'id: ' + repr(self.id) + ' ' +\
7380            'name: ' + repr(self.name) + ' ' +\
7381            'password: ' + repr(self.password) + ' ' +\
7382            'port: ' + repr(self.port) + ' ' +\
7383            'port_override: ' + repr(self.port_override) + ' ' +\
7384            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
7385            'tags: ' + repr(self.tags) + ' ' +\
7386            'username: ' + repr(self.username) + ' ' +\
7387            '>'
7388
7389    def to_dict(self):
7390        return {
7391            'bind_interface': self.bind_interface,
7392            'database': self.database,
7393            'egress_filter': self.egress_filter,
7394            'healthy': self.healthy,
7395            'hostname': self.hostname,
7396            'id': self.id,
7397            'name': self.name,
7398            'password': self.password,
7399            'port': self.port,
7400            'port_override': self.port_override,
7401            'secret_store_id': self.secret_store_id,
7402            'tags': self.tags,
7403            'username': self.username,
7404        }
7405
7406    @classmethod
7407    def from_dict(cls, d):
7408        return cls(
7409            bind_interface=d.get('bind_interface'),
7410            database=d.get('database'),
7411            egress_filter=d.get('egress_filter'),
7412            healthy=d.get('healthy'),
7413            hostname=d.get('hostname'),
7414            id=d.get('id'),
7415            name=d.get('name'),
7416            password=d.get('password'),
7417            port=d.get('port'),
7418            port_override=d.get('port_override'),
7419            secret_store_id=d.get('secret_store_id'),
7420            tags=d.get('tags'),
7421            username=d.get('username'),
7422        )
Maria( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
7303    def __init__(
7304        self,
7305        bind_interface=None,
7306        database=None,
7307        egress_filter=None,
7308        healthy=None,
7309        hostname=None,
7310        id=None,
7311        name=None,
7312        password=None,
7313        port=None,
7314        port_override=None,
7315        secret_store_id=None,
7316        tags=None,
7317        username=None,
7318    ):
7319        self.bind_interface = bind_interface if bind_interface is not None else ''
7320        '''
7321         Bind interface
7322        '''
7323        self.database = database if database is not None else ''
7324        '''
7325
7326        '''
7327        self.egress_filter = egress_filter if egress_filter is not None else ''
7328        '''
7329         A filter applied to the routing logic to pin datasource to nodes.
7330        '''
7331        self.healthy = healthy if healthy is not None else False
7332        '''
7333         True if the datasource is reachable and the credentials are valid.
7334        '''
7335        self.hostname = hostname if hostname is not None else ''
7336        '''
7337
7338        '''
7339        self.id = id if id is not None else ''
7340        '''
7341         Unique identifier of the Resource.
7342        '''
7343        self.name = name if name is not None else ''
7344        '''
7345         Unique human-readable name of the Resource.
7346        '''
7347        self.password = password if password is not None else ''
7348        '''
7349
7350        '''
7351        self.port = port if port is not None else 0
7352        '''
7353
7354        '''
7355        self.port_override = port_override if port_override is not None else 0
7356        '''
7357
7358        '''
7359        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7360        '''
7361         ID of the secret store containing credentials for this resource, if any.
7362        '''
7363        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7364        '''
7365         Tags is a map of key, value pairs.
7366        '''
7367        self.username = username if username is not None else ''
7368        '''
7369
7370        '''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
7389    def to_dict(self):
7390        return {
7391            'bind_interface': self.bind_interface,
7392            'database': self.database,
7393            'egress_filter': self.egress_filter,
7394            'healthy': self.healthy,
7395            'hostname': self.hostname,
7396            'id': self.id,
7397            'name': self.name,
7398            'password': self.password,
7399            'port': self.port,
7400            'port_override': self.port_override,
7401            'secret_store_id': self.secret_store_id,
7402            'tags': self.tags,
7403            'username': self.username,
7404        }
@classmethod
def from_dict(cls, d)
7406    @classmethod
7407    def from_dict(cls, d):
7408        return cls(
7409            bind_interface=d.get('bind_interface'),
7410            database=d.get('database'),
7411            egress_filter=d.get('egress_filter'),
7412            healthy=d.get('healthy'),
7413            hostname=d.get('hostname'),
7414            id=d.get('id'),
7415            name=d.get('name'),
7416            password=d.get('password'),
7417            port=d.get('port'),
7418            port_override=d.get('port_override'),
7419            secret_store_id=d.get('secret_store_id'),
7420            tags=d.get('tags'),
7421            username=d.get('username'),
7422        )
class Memcached:
7425class Memcached:
7426    '''
7427
7428    '''
7429    __slots__ = [
7430        'bind_interface',
7431        'egress_filter',
7432        'healthy',
7433        'hostname',
7434        'id',
7435        'name',
7436        'port',
7437        'port_override',
7438        'secret_store_id',
7439        'tags',
7440    ]
7441
7442    def __init__(
7443        self,
7444        bind_interface=None,
7445        egress_filter=None,
7446        healthy=None,
7447        hostname=None,
7448        id=None,
7449        name=None,
7450        port=None,
7451        port_override=None,
7452        secret_store_id=None,
7453        tags=None,
7454    ):
7455        self.bind_interface = bind_interface if bind_interface is not None else ''
7456        '''
7457         Bind interface
7458        '''
7459        self.egress_filter = egress_filter if egress_filter is not None else ''
7460        '''
7461         A filter applied to the routing logic to pin datasource to nodes.
7462        '''
7463        self.healthy = healthy if healthy is not None else False
7464        '''
7465         True if the datasource is reachable and the credentials are valid.
7466        '''
7467        self.hostname = hostname if hostname is not None else ''
7468        '''
7469
7470        '''
7471        self.id = id if id is not None else ''
7472        '''
7473         Unique identifier of the Resource.
7474        '''
7475        self.name = name if name is not None else ''
7476        '''
7477         Unique human-readable name of the Resource.
7478        '''
7479        self.port = port if port is not None else 0
7480        '''
7481
7482        '''
7483        self.port_override = port_override if port_override is not None else 0
7484        '''
7485
7486        '''
7487        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7488        '''
7489         ID of the secret store containing credentials for this resource, if any.
7490        '''
7491        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7492        '''
7493         Tags is a map of key, value pairs.
7494        '''
7495
7496    def __repr__(self):
7497        return '<sdm.Memcached ' + \
7498            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
7499            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
7500            'healthy: ' + repr(self.healthy) + ' ' +\
7501            'hostname: ' + repr(self.hostname) + ' ' +\
7502            'id: ' + repr(self.id) + ' ' +\
7503            'name: ' + repr(self.name) + ' ' +\
7504            'port: ' + repr(self.port) + ' ' +\
7505            'port_override: ' + repr(self.port_override) + ' ' +\
7506            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
7507            'tags: ' + repr(self.tags) + ' ' +\
7508            '>'
7509
7510    def to_dict(self):
7511        return {
7512            'bind_interface': self.bind_interface,
7513            'egress_filter': self.egress_filter,
7514            'healthy': self.healthy,
7515            'hostname': self.hostname,
7516            'id': self.id,
7517            'name': self.name,
7518            'port': self.port,
7519            'port_override': self.port_override,
7520            'secret_store_id': self.secret_store_id,
7521            'tags': self.tags,
7522        }
7523
7524    @classmethod
7525    def from_dict(cls, d):
7526        return cls(
7527            bind_interface=d.get('bind_interface'),
7528            egress_filter=d.get('egress_filter'),
7529            healthy=d.get('healthy'),
7530            hostname=d.get('hostname'),
7531            id=d.get('id'),
7532            name=d.get('name'),
7533            port=d.get('port'),
7534            port_override=d.get('port_override'),
7535            secret_store_id=d.get('secret_store_id'),
7536            tags=d.get('tags'),
7537        )
Memcached( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, port=None, port_override=None, secret_store_id=None, tags=None)
7442    def __init__(
7443        self,
7444        bind_interface=None,
7445        egress_filter=None,
7446        healthy=None,
7447        hostname=None,
7448        id=None,
7449        name=None,
7450        port=None,
7451        port_override=None,
7452        secret_store_id=None,
7453        tags=None,
7454    ):
7455        self.bind_interface = bind_interface if bind_interface is not None else ''
7456        '''
7457         Bind interface
7458        '''
7459        self.egress_filter = egress_filter if egress_filter is not None else ''
7460        '''
7461         A filter applied to the routing logic to pin datasource to nodes.
7462        '''
7463        self.healthy = healthy if healthy is not None else False
7464        '''
7465         True if the datasource is reachable and the credentials are valid.
7466        '''
7467        self.hostname = hostname if hostname is not None else ''
7468        '''
7469
7470        '''
7471        self.id = id if id is not None else ''
7472        '''
7473         Unique identifier of the Resource.
7474        '''
7475        self.name = name if name is not None else ''
7476        '''
7477         Unique human-readable name of the Resource.
7478        '''
7479        self.port = port if port is not None else 0
7480        '''
7481
7482        '''
7483        self.port_override = port_override if port_override is not None else 0
7484        '''
7485
7486        '''
7487        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7488        '''
7489         ID of the secret store containing credentials for this resource, if any.
7490        '''
7491        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7492        '''
7493         Tags is a map of key, value pairs.
7494        '''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
7510    def to_dict(self):
7511        return {
7512            'bind_interface': self.bind_interface,
7513            'egress_filter': self.egress_filter,
7514            'healthy': self.healthy,
7515            'hostname': self.hostname,
7516            'id': self.id,
7517            'name': self.name,
7518            'port': self.port,
7519            'port_override': self.port_override,
7520            'secret_store_id': self.secret_store_id,
7521            'tags': self.tags,
7522        }
@classmethod
def from_dict(cls, d)
7524    @classmethod
7525    def from_dict(cls, d):
7526        return cls(
7527            bind_interface=d.get('bind_interface'),
7528            egress_filter=d.get('egress_filter'),
7529            healthy=d.get('healthy'),
7530            hostname=d.get('hostname'),
7531            id=d.get('id'),
7532            name=d.get('name'),
7533            port=d.get('port'),
7534            port_override=d.get('port_override'),
7535            secret_store_id=d.get('secret_store_id'),
7536            tags=d.get('tags'),
7537        )
class Memsql:
7540class Memsql:
7541    '''
7542
7543    '''
7544    __slots__ = [
7545        'bind_interface',
7546        'database',
7547        'egress_filter',
7548        'healthy',
7549        'hostname',
7550        'id',
7551        'name',
7552        'password',
7553        'port',
7554        'port_override',
7555        'secret_store_id',
7556        'tags',
7557        'username',
7558    ]
7559
7560    def __init__(
7561        self,
7562        bind_interface=None,
7563        database=None,
7564        egress_filter=None,
7565        healthy=None,
7566        hostname=None,
7567        id=None,
7568        name=None,
7569        password=None,
7570        port=None,
7571        port_override=None,
7572        secret_store_id=None,
7573        tags=None,
7574        username=None,
7575    ):
7576        self.bind_interface = bind_interface if bind_interface is not None else ''
7577        '''
7578         Bind interface
7579        '''
7580        self.database = database if database is not None else ''
7581        '''
7582
7583        '''
7584        self.egress_filter = egress_filter if egress_filter is not None else ''
7585        '''
7586         A filter applied to the routing logic to pin datasource to nodes.
7587        '''
7588        self.healthy = healthy if healthy is not None else False
7589        '''
7590         True if the datasource is reachable and the credentials are valid.
7591        '''
7592        self.hostname = hostname if hostname is not None else ''
7593        '''
7594
7595        '''
7596        self.id = id if id is not None else ''
7597        '''
7598         Unique identifier of the Resource.
7599        '''
7600        self.name = name if name is not None else ''
7601        '''
7602         Unique human-readable name of the Resource.
7603        '''
7604        self.password = password if password is not None else ''
7605        '''
7606
7607        '''
7608        self.port = port if port is not None else 0
7609        '''
7610
7611        '''
7612        self.port_override = port_override if port_override is not None else 0
7613        '''
7614
7615        '''
7616        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7617        '''
7618         ID of the secret store containing credentials for this resource, if any.
7619        '''
7620        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7621        '''
7622         Tags is a map of key, value pairs.
7623        '''
7624        self.username = username if username is not None else ''
7625        '''
7626
7627        '''
7628
7629    def __repr__(self):
7630        return '<sdm.Memsql ' + \
7631            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
7632            'database: ' + repr(self.database) + ' ' +\
7633            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
7634            'healthy: ' + repr(self.healthy) + ' ' +\
7635            'hostname: ' + repr(self.hostname) + ' ' +\
7636            'id: ' + repr(self.id) + ' ' +\
7637            'name: ' + repr(self.name) + ' ' +\
7638            'password: ' + repr(self.password) + ' ' +\
7639            'port: ' + repr(self.port) + ' ' +\
7640            'port_override: ' + repr(self.port_override) + ' ' +\
7641            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
7642            'tags: ' + repr(self.tags) + ' ' +\
7643            'username: ' + repr(self.username) + ' ' +\
7644            '>'
7645
7646    def to_dict(self):
7647        return {
7648            'bind_interface': self.bind_interface,
7649            'database': self.database,
7650            'egress_filter': self.egress_filter,
7651            'healthy': self.healthy,
7652            'hostname': self.hostname,
7653            'id': self.id,
7654            'name': self.name,
7655            'password': self.password,
7656            'port': self.port,
7657            'port_override': self.port_override,
7658            'secret_store_id': self.secret_store_id,
7659            'tags': self.tags,
7660            'username': self.username,
7661        }
7662
7663    @classmethod
7664    def from_dict(cls, d):
7665        return cls(
7666            bind_interface=d.get('bind_interface'),
7667            database=d.get('database'),
7668            egress_filter=d.get('egress_filter'),
7669            healthy=d.get('healthy'),
7670            hostname=d.get('hostname'),
7671            id=d.get('id'),
7672            name=d.get('name'),
7673            password=d.get('password'),
7674            port=d.get('port'),
7675            port_override=d.get('port_override'),
7676            secret_store_id=d.get('secret_store_id'),
7677            tags=d.get('tags'),
7678            username=d.get('username'),
7679        )
Memsql( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
7560    def __init__(
7561        self,
7562        bind_interface=None,
7563        database=None,
7564        egress_filter=None,
7565        healthy=None,
7566        hostname=None,
7567        id=None,
7568        name=None,
7569        password=None,
7570        port=None,
7571        port_override=None,
7572        secret_store_id=None,
7573        tags=None,
7574        username=None,
7575    ):
7576        self.bind_interface = bind_interface if bind_interface is not None else ''
7577        '''
7578         Bind interface
7579        '''
7580        self.database = database if database is not None else ''
7581        '''
7582
7583        '''
7584        self.egress_filter = egress_filter if egress_filter is not None else ''
7585        '''
7586         A filter applied to the routing logic to pin datasource to nodes.
7587        '''
7588        self.healthy = healthy if healthy is not None else False
7589        '''
7590         True if the datasource is reachable and the credentials are valid.
7591        '''
7592        self.hostname = hostname if hostname is not None else ''
7593        '''
7594
7595        '''
7596        self.id = id if id is not None else ''
7597        '''
7598         Unique identifier of the Resource.
7599        '''
7600        self.name = name if name is not None else ''
7601        '''
7602         Unique human-readable name of the Resource.
7603        '''
7604        self.password = password if password is not None else ''
7605        '''
7606
7607        '''
7608        self.port = port if port is not None else 0
7609        '''
7610
7611        '''
7612        self.port_override = port_override if port_override is not None else 0
7613        '''
7614
7615        '''
7616        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7617        '''
7618         ID of the secret store containing credentials for this resource, if any.
7619        '''
7620        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7621        '''
7622         Tags is a map of key, value pairs.
7623        '''
7624        self.username = username if username is not None else ''
7625        '''
7626
7627        '''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
7646    def to_dict(self):
7647        return {
7648            'bind_interface': self.bind_interface,
7649            'database': self.database,
7650            'egress_filter': self.egress_filter,
7651            'healthy': self.healthy,
7652            'hostname': self.hostname,
7653            'id': self.id,
7654            'name': self.name,
7655            'password': self.password,
7656            'port': self.port,
7657            'port_override': self.port_override,
7658            'secret_store_id': self.secret_store_id,
7659            'tags': self.tags,
7660            'username': self.username,
7661        }
@classmethod
def from_dict(cls, d)
7663    @classmethod
7664    def from_dict(cls, d):
7665        return cls(
7666            bind_interface=d.get('bind_interface'),
7667            database=d.get('database'),
7668            egress_filter=d.get('egress_filter'),
7669            healthy=d.get('healthy'),
7670            hostname=d.get('hostname'),
7671            id=d.get('id'),
7672            name=d.get('name'),
7673            password=d.get('password'),
7674            port=d.get('port'),
7675            port_override=d.get('port_override'),
7676            secret_store_id=d.get('secret_store_id'),
7677            tags=d.get('tags'),
7678            username=d.get('username'),
7679        )
class MongoHost:
7682class MongoHost:
7683    '''
7684
7685    '''
7686    __slots__ = [
7687        'auth_database',
7688        'bind_interface',
7689        'egress_filter',
7690        'healthy',
7691        'hostname',
7692        'id',
7693        'name',
7694        'password',
7695        'port',
7696        'port_override',
7697        'secret_store_id',
7698        'tags',
7699        'tls_required',
7700        'username',
7701    ]
7702
7703    def __init__(
7704        self,
7705        auth_database=None,
7706        bind_interface=None,
7707        egress_filter=None,
7708        healthy=None,
7709        hostname=None,
7710        id=None,
7711        name=None,
7712        password=None,
7713        port=None,
7714        port_override=None,
7715        secret_store_id=None,
7716        tags=None,
7717        tls_required=None,
7718        username=None,
7719    ):
7720        self.auth_database = auth_database if auth_database is not None else ''
7721        '''
7722
7723        '''
7724        self.bind_interface = bind_interface if bind_interface is not None else ''
7725        '''
7726         Bind interface
7727        '''
7728        self.egress_filter = egress_filter if egress_filter is not None else ''
7729        '''
7730         A filter applied to the routing logic to pin datasource to nodes.
7731        '''
7732        self.healthy = healthy if healthy is not None else False
7733        '''
7734         True if the datasource is reachable and the credentials are valid.
7735        '''
7736        self.hostname = hostname if hostname is not None else ''
7737        '''
7738
7739        '''
7740        self.id = id if id is not None else ''
7741        '''
7742         Unique identifier of the Resource.
7743        '''
7744        self.name = name if name is not None else ''
7745        '''
7746         Unique human-readable name of the Resource.
7747        '''
7748        self.password = password if password is not None else ''
7749        '''
7750
7751        '''
7752        self.port = port if port is not None else 0
7753        '''
7754
7755        '''
7756        self.port_override = port_override if port_override is not None else 0
7757        '''
7758
7759        '''
7760        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7761        '''
7762         ID of the secret store containing credentials for this resource, if any.
7763        '''
7764        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7765        '''
7766         Tags is a map of key, value pairs.
7767        '''
7768        self.tls_required = tls_required if tls_required is not None else False
7769        '''
7770
7771        '''
7772        self.username = username if username is not None else ''
7773        '''
7774
7775        '''
7776
7777    def __repr__(self):
7778        return '<sdm.MongoHost ' + \
7779            'auth_database: ' + repr(self.auth_database) + ' ' +\
7780            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
7781            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
7782            'healthy: ' + repr(self.healthy) + ' ' +\
7783            'hostname: ' + repr(self.hostname) + ' ' +\
7784            'id: ' + repr(self.id) + ' ' +\
7785            'name: ' + repr(self.name) + ' ' +\
7786            'password: ' + repr(self.password) + ' ' +\
7787            'port: ' + repr(self.port) + ' ' +\
7788            'port_override: ' + repr(self.port_override) + ' ' +\
7789            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
7790            'tags: ' + repr(self.tags) + ' ' +\
7791            'tls_required: ' + repr(self.tls_required) + ' ' +\
7792            'username: ' + repr(self.username) + ' ' +\
7793            '>'
7794
7795    def to_dict(self):
7796        return {
7797            'auth_database': self.auth_database,
7798            'bind_interface': self.bind_interface,
7799            'egress_filter': self.egress_filter,
7800            'healthy': self.healthy,
7801            'hostname': self.hostname,
7802            'id': self.id,
7803            'name': self.name,
7804            'password': self.password,
7805            'port': self.port,
7806            'port_override': self.port_override,
7807            'secret_store_id': self.secret_store_id,
7808            'tags': self.tags,
7809            'tls_required': self.tls_required,
7810            'username': self.username,
7811        }
7812
7813    @classmethod
7814    def from_dict(cls, d):
7815        return cls(
7816            auth_database=d.get('auth_database'),
7817            bind_interface=d.get('bind_interface'),
7818            egress_filter=d.get('egress_filter'),
7819            healthy=d.get('healthy'),
7820            hostname=d.get('hostname'),
7821            id=d.get('id'),
7822            name=d.get('name'),
7823            password=d.get('password'),
7824            port=d.get('port'),
7825            port_override=d.get('port_override'),
7826            secret_store_id=d.get('secret_store_id'),
7827            tags=d.get('tags'),
7828            tls_required=d.get('tls_required'),
7829            username=d.get('username'),
7830        )
MongoHost( auth_database=None, bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, tls_required=None, username=None)
7703    def __init__(
7704        self,
7705        auth_database=None,
7706        bind_interface=None,
7707        egress_filter=None,
7708        healthy=None,
7709        hostname=None,
7710        id=None,
7711        name=None,
7712        password=None,
7713        port=None,
7714        port_override=None,
7715        secret_store_id=None,
7716        tags=None,
7717        tls_required=None,
7718        username=None,
7719    ):
7720        self.auth_database = auth_database if auth_database is not None else ''
7721        '''
7722
7723        '''
7724        self.bind_interface = bind_interface if bind_interface is not None else ''
7725        '''
7726         Bind interface
7727        '''
7728        self.egress_filter = egress_filter if egress_filter is not None else ''
7729        '''
7730         A filter applied to the routing logic to pin datasource to nodes.
7731        '''
7732        self.healthy = healthy if healthy is not None else False
7733        '''
7734         True if the datasource is reachable and the credentials are valid.
7735        '''
7736        self.hostname = hostname if hostname is not None else ''
7737        '''
7738
7739        '''
7740        self.id = id if id is not None else ''
7741        '''
7742         Unique identifier of the Resource.
7743        '''
7744        self.name = name if name is not None else ''
7745        '''
7746         Unique human-readable name of the Resource.
7747        '''
7748        self.password = password if password is not None else ''
7749        '''
7750
7751        '''
7752        self.port = port if port is not None else 0
7753        '''
7754
7755        '''
7756        self.port_override = port_override if port_override is not None else 0
7757        '''
7758
7759        '''
7760        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7761        '''
7762         ID of the secret store containing credentials for this resource, if any.
7763        '''
7764        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7765        '''
7766         Tags is a map of key, value pairs.
7767        '''
7768        self.tls_required = tls_required if tls_required is not None else False
7769        '''
7770
7771        '''
7772        self.username = username if username is not None else ''
7773        '''
7774
7775        '''
auth_database
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
7795    def to_dict(self):
7796        return {
7797            'auth_database': self.auth_database,
7798            'bind_interface': self.bind_interface,
7799            'egress_filter': self.egress_filter,
7800            'healthy': self.healthy,
7801            'hostname': self.hostname,
7802            'id': self.id,
7803            'name': self.name,
7804            'password': self.password,
7805            'port': self.port,
7806            'port_override': self.port_override,
7807            'secret_store_id': self.secret_store_id,
7808            'tags': self.tags,
7809            'tls_required': self.tls_required,
7810            'username': self.username,
7811        }
@classmethod
def from_dict(cls, d)
7813    @classmethod
7814    def from_dict(cls, d):
7815        return cls(
7816            auth_database=d.get('auth_database'),
7817            bind_interface=d.get('bind_interface'),
7818            egress_filter=d.get('egress_filter'),
7819            healthy=d.get('healthy'),
7820            hostname=d.get('hostname'),
7821            id=d.get('id'),
7822            name=d.get('name'),
7823            password=d.get('password'),
7824            port=d.get('port'),
7825            port_override=d.get('port_override'),
7826            secret_store_id=d.get('secret_store_id'),
7827            tags=d.get('tags'),
7828            tls_required=d.get('tls_required'),
7829            username=d.get('username'),
7830        )
class MongoLegacyHost:
7833class MongoLegacyHost:
7834    '''
7835
7836    '''
7837    __slots__ = [
7838        'auth_database',
7839        'bind_interface',
7840        'egress_filter',
7841        'healthy',
7842        'hostname',
7843        'id',
7844        'name',
7845        'password',
7846        'port',
7847        'port_override',
7848        'replica_set',
7849        'secret_store_id',
7850        'tags',
7851        'tls_required',
7852        'username',
7853    ]
7854
7855    def __init__(
7856        self,
7857        auth_database=None,
7858        bind_interface=None,
7859        egress_filter=None,
7860        healthy=None,
7861        hostname=None,
7862        id=None,
7863        name=None,
7864        password=None,
7865        port=None,
7866        port_override=None,
7867        replica_set=None,
7868        secret_store_id=None,
7869        tags=None,
7870        tls_required=None,
7871        username=None,
7872    ):
7873        self.auth_database = auth_database if auth_database is not None else ''
7874        '''
7875
7876        '''
7877        self.bind_interface = bind_interface if bind_interface is not None else ''
7878        '''
7879         Bind interface
7880        '''
7881        self.egress_filter = egress_filter if egress_filter is not None else ''
7882        '''
7883         A filter applied to the routing logic to pin datasource to nodes.
7884        '''
7885        self.healthy = healthy if healthy is not None else False
7886        '''
7887         True if the datasource is reachable and the credentials are valid.
7888        '''
7889        self.hostname = hostname if hostname is not None else ''
7890        '''
7891
7892        '''
7893        self.id = id if id is not None else ''
7894        '''
7895         Unique identifier of the Resource.
7896        '''
7897        self.name = name if name is not None else ''
7898        '''
7899         Unique human-readable name of the Resource.
7900        '''
7901        self.password = password if password is not None else ''
7902        '''
7903
7904        '''
7905        self.port = port if port is not None else 0
7906        '''
7907
7908        '''
7909        self.port_override = port_override if port_override is not None else 0
7910        '''
7911
7912        '''
7913        self.replica_set = replica_set if replica_set is not None else ''
7914        '''
7915
7916        '''
7917        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7918        '''
7919         ID of the secret store containing credentials for this resource, if any.
7920        '''
7921        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7922        '''
7923         Tags is a map of key, value pairs.
7924        '''
7925        self.tls_required = tls_required if tls_required is not None else False
7926        '''
7927
7928        '''
7929        self.username = username if username is not None else ''
7930        '''
7931
7932        '''
7933
7934    def __repr__(self):
7935        return '<sdm.MongoLegacyHost ' + \
7936            'auth_database: ' + repr(self.auth_database) + ' ' +\
7937            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
7938            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
7939            'healthy: ' + repr(self.healthy) + ' ' +\
7940            'hostname: ' + repr(self.hostname) + ' ' +\
7941            'id: ' + repr(self.id) + ' ' +\
7942            'name: ' + repr(self.name) + ' ' +\
7943            'password: ' + repr(self.password) + ' ' +\
7944            'port: ' + repr(self.port) + ' ' +\
7945            'port_override: ' + repr(self.port_override) + ' ' +\
7946            'replica_set: ' + repr(self.replica_set) + ' ' +\
7947            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
7948            'tags: ' + repr(self.tags) + ' ' +\
7949            'tls_required: ' + repr(self.tls_required) + ' ' +\
7950            'username: ' + repr(self.username) + ' ' +\
7951            '>'
7952
7953    def to_dict(self):
7954        return {
7955            'auth_database': self.auth_database,
7956            'bind_interface': self.bind_interface,
7957            'egress_filter': self.egress_filter,
7958            'healthy': self.healthy,
7959            'hostname': self.hostname,
7960            'id': self.id,
7961            'name': self.name,
7962            'password': self.password,
7963            'port': self.port,
7964            'port_override': self.port_override,
7965            'replica_set': self.replica_set,
7966            'secret_store_id': self.secret_store_id,
7967            'tags': self.tags,
7968            'tls_required': self.tls_required,
7969            'username': self.username,
7970        }
7971
7972    @classmethod
7973    def from_dict(cls, d):
7974        return cls(
7975            auth_database=d.get('auth_database'),
7976            bind_interface=d.get('bind_interface'),
7977            egress_filter=d.get('egress_filter'),
7978            healthy=d.get('healthy'),
7979            hostname=d.get('hostname'),
7980            id=d.get('id'),
7981            name=d.get('name'),
7982            password=d.get('password'),
7983            port=d.get('port'),
7984            port_override=d.get('port_override'),
7985            replica_set=d.get('replica_set'),
7986            secret_store_id=d.get('secret_store_id'),
7987            tags=d.get('tags'),
7988            tls_required=d.get('tls_required'),
7989            username=d.get('username'),
7990        )
MongoLegacyHost( auth_database=None, bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, replica_set=None, secret_store_id=None, tags=None, tls_required=None, username=None)
7855    def __init__(
7856        self,
7857        auth_database=None,
7858        bind_interface=None,
7859        egress_filter=None,
7860        healthy=None,
7861        hostname=None,
7862        id=None,
7863        name=None,
7864        password=None,
7865        port=None,
7866        port_override=None,
7867        replica_set=None,
7868        secret_store_id=None,
7869        tags=None,
7870        tls_required=None,
7871        username=None,
7872    ):
7873        self.auth_database = auth_database if auth_database is not None else ''
7874        '''
7875
7876        '''
7877        self.bind_interface = bind_interface if bind_interface is not None else ''
7878        '''
7879         Bind interface
7880        '''
7881        self.egress_filter = egress_filter if egress_filter is not None else ''
7882        '''
7883         A filter applied to the routing logic to pin datasource to nodes.
7884        '''
7885        self.healthy = healthy if healthy is not None else False
7886        '''
7887         True if the datasource is reachable and the credentials are valid.
7888        '''
7889        self.hostname = hostname if hostname is not None else ''
7890        '''
7891
7892        '''
7893        self.id = id if id is not None else ''
7894        '''
7895         Unique identifier of the Resource.
7896        '''
7897        self.name = name if name is not None else ''
7898        '''
7899         Unique human-readable name of the Resource.
7900        '''
7901        self.password = password if password is not None else ''
7902        '''
7903
7904        '''
7905        self.port = port if port is not None else 0
7906        '''
7907
7908        '''
7909        self.port_override = port_override if port_override is not None else 0
7910        '''
7911
7912        '''
7913        self.replica_set = replica_set if replica_set is not None else ''
7914        '''
7915
7916        '''
7917        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
7918        '''
7919         ID of the secret store containing credentials for this resource, if any.
7920        '''
7921        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
7922        '''
7923         Tags is a map of key, value pairs.
7924        '''
7925        self.tls_required = tls_required if tls_required is not None else False
7926        '''
7927
7928        '''
7929        self.username = username if username is not None else ''
7930        '''
7931
7932        '''
auth_database
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
replica_set
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
7953    def to_dict(self):
7954        return {
7955            'auth_database': self.auth_database,
7956            'bind_interface': self.bind_interface,
7957            'egress_filter': self.egress_filter,
7958            'healthy': self.healthy,
7959            'hostname': self.hostname,
7960            'id': self.id,
7961            'name': self.name,
7962            'password': self.password,
7963            'port': self.port,
7964            'port_override': self.port_override,
7965            'replica_set': self.replica_set,
7966            'secret_store_id': self.secret_store_id,
7967            'tags': self.tags,
7968            'tls_required': self.tls_required,
7969            'username': self.username,
7970        }
@classmethod
def from_dict(cls, d)
7972    @classmethod
7973    def from_dict(cls, d):
7974        return cls(
7975            auth_database=d.get('auth_database'),
7976            bind_interface=d.get('bind_interface'),
7977            egress_filter=d.get('egress_filter'),
7978            healthy=d.get('healthy'),
7979            hostname=d.get('hostname'),
7980            id=d.get('id'),
7981            name=d.get('name'),
7982            password=d.get('password'),
7983            port=d.get('port'),
7984            port_override=d.get('port_override'),
7985            replica_set=d.get('replica_set'),
7986            secret_store_id=d.get('secret_store_id'),
7987            tags=d.get('tags'),
7988            tls_required=d.get('tls_required'),
7989            username=d.get('username'),
7990        )
class MongoLegacyReplicaset:
7993class MongoLegacyReplicaset:
7994    '''
7995
7996    '''
7997    __slots__ = [
7998        'auth_database',
7999        'bind_interface',
8000        'connect_to_replica',
8001        'egress_filter',
8002        'healthy',
8003        'hostname',
8004        'id',
8005        'name',
8006        'password',
8007        'port',
8008        'port_override',
8009        'replica_set',
8010        'secret_store_id',
8011        'tags',
8012        'tls_required',
8013        'username',
8014    ]
8015
8016    def __init__(
8017        self,
8018        auth_database=None,
8019        bind_interface=None,
8020        connect_to_replica=None,
8021        egress_filter=None,
8022        healthy=None,
8023        hostname=None,
8024        id=None,
8025        name=None,
8026        password=None,
8027        port=None,
8028        port_override=None,
8029        replica_set=None,
8030        secret_store_id=None,
8031        tags=None,
8032        tls_required=None,
8033        username=None,
8034    ):
8035        self.auth_database = auth_database if auth_database is not None else ''
8036        '''
8037
8038        '''
8039        self.bind_interface = bind_interface if bind_interface is not None else ''
8040        '''
8041         Bind interface
8042        '''
8043        self.connect_to_replica = connect_to_replica if connect_to_replica is not None else False
8044        '''
8045
8046        '''
8047        self.egress_filter = egress_filter if egress_filter is not None else ''
8048        '''
8049         A filter applied to the routing logic to pin datasource to nodes.
8050        '''
8051        self.healthy = healthy if healthy is not None else False
8052        '''
8053         True if the datasource is reachable and the credentials are valid.
8054        '''
8055        self.hostname = hostname if hostname is not None else ''
8056        '''
8057
8058        '''
8059        self.id = id if id is not None else ''
8060        '''
8061         Unique identifier of the Resource.
8062        '''
8063        self.name = name if name is not None else ''
8064        '''
8065         Unique human-readable name of the Resource.
8066        '''
8067        self.password = password if password is not None else ''
8068        '''
8069
8070        '''
8071        self.port = port if port is not None else 0
8072        '''
8073
8074        '''
8075        self.port_override = port_override if port_override is not None else 0
8076        '''
8077
8078        '''
8079        self.replica_set = replica_set if replica_set is not None else ''
8080        '''
8081
8082        '''
8083        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8084        '''
8085         ID of the secret store containing credentials for this resource, if any.
8086        '''
8087        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8088        '''
8089         Tags is a map of key, value pairs.
8090        '''
8091        self.tls_required = tls_required if tls_required is not None else False
8092        '''
8093
8094        '''
8095        self.username = username if username is not None else ''
8096        '''
8097
8098        '''
8099
8100    def __repr__(self):
8101        return '<sdm.MongoLegacyReplicaset ' + \
8102            'auth_database: ' + repr(self.auth_database) + ' ' +\
8103            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
8104            'connect_to_replica: ' + repr(self.connect_to_replica) + ' ' +\
8105            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
8106            'healthy: ' + repr(self.healthy) + ' ' +\
8107            'hostname: ' + repr(self.hostname) + ' ' +\
8108            'id: ' + repr(self.id) + ' ' +\
8109            'name: ' + repr(self.name) + ' ' +\
8110            'password: ' + repr(self.password) + ' ' +\
8111            'port: ' + repr(self.port) + ' ' +\
8112            'port_override: ' + repr(self.port_override) + ' ' +\
8113            'replica_set: ' + repr(self.replica_set) + ' ' +\
8114            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
8115            'tags: ' + repr(self.tags) + ' ' +\
8116            'tls_required: ' + repr(self.tls_required) + ' ' +\
8117            'username: ' + repr(self.username) + ' ' +\
8118            '>'
8119
8120    def to_dict(self):
8121        return {
8122            'auth_database': self.auth_database,
8123            'bind_interface': self.bind_interface,
8124            'connect_to_replica': self.connect_to_replica,
8125            'egress_filter': self.egress_filter,
8126            'healthy': self.healthy,
8127            'hostname': self.hostname,
8128            'id': self.id,
8129            'name': self.name,
8130            'password': self.password,
8131            'port': self.port,
8132            'port_override': self.port_override,
8133            'replica_set': self.replica_set,
8134            'secret_store_id': self.secret_store_id,
8135            'tags': self.tags,
8136            'tls_required': self.tls_required,
8137            'username': self.username,
8138        }
8139
8140    @classmethod
8141    def from_dict(cls, d):
8142        return cls(
8143            auth_database=d.get('auth_database'),
8144            bind_interface=d.get('bind_interface'),
8145            connect_to_replica=d.get('connect_to_replica'),
8146            egress_filter=d.get('egress_filter'),
8147            healthy=d.get('healthy'),
8148            hostname=d.get('hostname'),
8149            id=d.get('id'),
8150            name=d.get('name'),
8151            password=d.get('password'),
8152            port=d.get('port'),
8153            port_override=d.get('port_override'),
8154            replica_set=d.get('replica_set'),
8155            secret_store_id=d.get('secret_store_id'),
8156            tags=d.get('tags'),
8157            tls_required=d.get('tls_required'),
8158            username=d.get('username'),
8159        )
MongoLegacyReplicaset( auth_database=None, bind_interface=None, connect_to_replica=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, replica_set=None, secret_store_id=None, tags=None, tls_required=None, username=None)
8016    def __init__(
8017        self,
8018        auth_database=None,
8019        bind_interface=None,
8020        connect_to_replica=None,
8021        egress_filter=None,
8022        healthy=None,
8023        hostname=None,
8024        id=None,
8025        name=None,
8026        password=None,
8027        port=None,
8028        port_override=None,
8029        replica_set=None,
8030        secret_store_id=None,
8031        tags=None,
8032        tls_required=None,
8033        username=None,
8034    ):
8035        self.auth_database = auth_database if auth_database is not None else ''
8036        '''
8037
8038        '''
8039        self.bind_interface = bind_interface if bind_interface is not None else ''
8040        '''
8041         Bind interface
8042        '''
8043        self.connect_to_replica = connect_to_replica if connect_to_replica is not None else False
8044        '''
8045
8046        '''
8047        self.egress_filter = egress_filter if egress_filter is not None else ''
8048        '''
8049         A filter applied to the routing logic to pin datasource to nodes.
8050        '''
8051        self.healthy = healthy if healthy is not None else False
8052        '''
8053         True if the datasource is reachable and the credentials are valid.
8054        '''
8055        self.hostname = hostname if hostname is not None else ''
8056        '''
8057
8058        '''
8059        self.id = id if id is not None else ''
8060        '''
8061         Unique identifier of the Resource.
8062        '''
8063        self.name = name if name is not None else ''
8064        '''
8065         Unique human-readable name of the Resource.
8066        '''
8067        self.password = password if password is not None else ''
8068        '''
8069
8070        '''
8071        self.port = port if port is not None else 0
8072        '''
8073
8074        '''
8075        self.port_override = port_override if port_override is not None else 0
8076        '''
8077
8078        '''
8079        self.replica_set = replica_set if replica_set is not None else ''
8080        '''
8081
8082        '''
8083        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8084        '''
8085         ID of the secret store containing credentials for this resource, if any.
8086        '''
8087        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8088        '''
8089         Tags is a map of key, value pairs.
8090        '''
8091        self.tls_required = tls_required if tls_required is not None else False
8092        '''
8093
8094        '''
8095        self.username = username if username is not None else ''
8096        '''
8097
8098        '''
auth_database
bind_interface

Bind interface

connect_to_replica
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
replica_set
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
8120    def to_dict(self):
8121        return {
8122            'auth_database': self.auth_database,
8123            'bind_interface': self.bind_interface,
8124            'connect_to_replica': self.connect_to_replica,
8125            'egress_filter': self.egress_filter,
8126            'healthy': self.healthy,
8127            'hostname': self.hostname,
8128            'id': self.id,
8129            'name': self.name,
8130            'password': self.password,
8131            'port': self.port,
8132            'port_override': self.port_override,
8133            'replica_set': self.replica_set,
8134            'secret_store_id': self.secret_store_id,
8135            'tags': self.tags,
8136            'tls_required': self.tls_required,
8137            'username': self.username,
8138        }
@classmethod
def from_dict(cls, d)
8140    @classmethod
8141    def from_dict(cls, d):
8142        return cls(
8143            auth_database=d.get('auth_database'),
8144            bind_interface=d.get('bind_interface'),
8145            connect_to_replica=d.get('connect_to_replica'),
8146            egress_filter=d.get('egress_filter'),
8147            healthy=d.get('healthy'),
8148            hostname=d.get('hostname'),
8149            id=d.get('id'),
8150            name=d.get('name'),
8151            password=d.get('password'),
8152            port=d.get('port'),
8153            port_override=d.get('port_override'),
8154            replica_set=d.get('replica_set'),
8155            secret_store_id=d.get('secret_store_id'),
8156            tags=d.get('tags'),
8157            tls_required=d.get('tls_required'),
8158            username=d.get('username'),
8159        )
class MongoReplicaSet:
8162class MongoReplicaSet:
8163    '''
8164
8165    '''
8166    __slots__ = [
8167        'auth_database',
8168        'bind_interface',
8169        'connect_to_replica',
8170        'egress_filter',
8171        'healthy',
8172        'hostname',
8173        'id',
8174        'name',
8175        'password',
8176        'port',
8177        'port_override',
8178        'replica_set',
8179        'secret_store_id',
8180        'tags',
8181        'tls_required',
8182        'username',
8183    ]
8184
8185    def __init__(
8186        self,
8187        auth_database=None,
8188        bind_interface=None,
8189        connect_to_replica=None,
8190        egress_filter=None,
8191        healthy=None,
8192        hostname=None,
8193        id=None,
8194        name=None,
8195        password=None,
8196        port=None,
8197        port_override=None,
8198        replica_set=None,
8199        secret_store_id=None,
8200        tags=None,
8201        tls_required=None,
8202        username=None,
8203    ):
8204        self.auth_database = auth_database if auth_database is not None else ''
8205        '''
8206
8207        '''
8208        self.bind_interface = bind_interface if bind_interface is not None else ''
8209        '''
8210         Bind interface
8211        '''
8212        self.connect_to_replica = connect_to_replica if connect_to_replica is not None else False
8213        '''
8214
8215        '''
8216        self.egress_filter = egress_filter if egress_filter is not None else ''
8217        '''
8218         A filter applied to the routing logic to pin datasource to nodes.
8219        '''
8220        self.healthy = healthy if healthy is not None else False
8221        '''
8222         True if the datasource is reachable and the credentials are valid.
8223        '''
8224        self.hostname = hostname if hostname is not None else ''
8225        '''
8226
8227        '''
8228        self.id = id if id is not None else ''
8229        '''
8230         Unique identifier of the Resource.
8231        '''
8232        self.name = name if name is not None else ''
8233        '''
8234         Unique human-readable name of the Resource.
8235        '''
8236        self.password = password if password is not None else ''
8237        '''
8238
8239        '''
8240        self.port = port if port is not None else 0
8241        '''
8242
8243        '''
8244        self.port_override = port_override if port_override is not None else 0
8245        '''
8246
8247        '''
8248        self.replica_set = replica_set if replica_set is not None else ''
8249        '''
8250
8251        '''
8252        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8253        '''
8254         ID of the secret store containing credentials for this resource, if any.
8255        '''
8256        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8257        '''
8258         Tags is a map of key, value pairs.
8259        '''
8260        self.tls_required = tls_required if tls_required is not None else False
8261        '''
8262
8263        '''
8264        self.username = username if username is not None else ''
8265        '''
8266
8267        '''
8268
8269    def __repr__(self):
8270        return '<sdm.MongoReplicaSet ' + \
8271            'auth_database: ' + repr(self.auth_database) + ' ' +\
8272            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
8273            'connect_to_replica: ' + repr(self.connect_to_replica) + ' ' +\
8274            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
8275            'healthy: ' + repr(self.healthy) + ' ' +\
8276            'hostname: ' + repr(self.hostname) + ' ' +\
8277            'id: ' + repr(self.id) + ' ' +\
8278            'name: ' + repr(self.name) + ' ' +\
8279            'password: ' + repr(self.password) + ' ' +\
8280            'port: ' + repr(self.port) + ' ' +\
8281            'port_override: ' + repr(self.port_override) + ' ' +\
8282            'replica_set: ' + repr(self.replica_set) + ' ' +\
8283            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
8284            'tags: ' + repr(self.tags) + ' ' +\
8285            'tls_required: ' + repr(self.tls_required) + ' ' +\
8286            'username: ' + repr(self.username) + ' ' +\
8287            '>'
8288
8289    def to_dict(self):
8290        return {
8291            'auth_database': self.auth_database,
8292            'bind_interface': self.bind_interface,
8293            'connect_to_replica': self.connect_to_replica,
8294            'egress_filter': self.egress_filter,
8295            'healthy': self.healthy,
8296            'hostname': self.hostname,
8297            'id': self.id,
8298            'name': self.name,
8299            'password': self.password,
8300            'port': self.port,
8301            'port_override': self.port_override,
8302            'replica_set': self.replica_set,
8303            'secret_store_id': self.secret_store_id,
8304            'tags': self.tags,
8305            'tls_required': self.tls_required,
8306            'username': self.username,
8307        }
8308
8309    @classmethod
8310    def from_dict(cls, d):
8311        return cls(
8312            auth_database=d.get('auth_database'),
8313            bind_interface=d.get('bind_interface'),
8314            connect_to_replica=d.get('connect_to_replica'),
8315            egress_filter=d.get('egress_filter'),
8316            healthy=d.get('healthy'),
8317            hostname=d.get('hostname'),
8318            id=d.get('id'),
8319            name=d.get('name'),
8320            password=d.get('password'),
8321            port=d.get('port'),
8322            port_override=d.get('port_override'),
8323            replica_set=d.get('replica_set'),
8324            secret_store_id=d.get('secret_store_id'),
8325            tags=d.get('tags'),
8326            tls_required=d.get('tls_required'),
8327            username=d.get('username'),
8328        )
MongoReplicaSet( auth_database=None, bind_interface=None, connect_to_replica=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, replica_set=None, secret_store_id=None, tags=None, tls_required=None, username=None)
8185    def __init__(
8186        self,
8187        auth_database=None,
8188        bind_interface=None,
8189        connect_to_replica=None,
8190        egress_filter=None,
8191        healthy=None,
8192        hostname=None,
8193        id=None,
8194        name=None,
8195        password=None,
8196        port=None,
8197        port_override=None,
8198        replica_set=None,
8199        secret_store_id=None,
8200        tags=None,
8201        tls_required=None,
8202        username=None,
8203    ):
8204        self.auth_database = auth_database if auth_database is not None else ''
8205        '''
8206
8207        '''
8208        self.bind_interface = bind_interface if bind_interface is not None else ''
8209        '''
8210         Bind interface
8211        '''
8212        self.connect_to_replica = connect_to_replica if connect_to_replica is not None else False
8213        '''
8214
8215        '''
8216        self.egress_filter = egress_filter if egress_filter is not None else ''
8217        '''
8218         A filter applied to the routing logic to pin datasource to nodes.
8219        '''
8220        self.healthy = healthy if healthy is not None else False
8221        '''
8222         True if the datasource is reachable and the credentials are valid.
8223        '''
8224        self.hostname = hostname if hostname is not None else ''
8225        '''
8226
8227        '''
8228        self.id = id if id is not None else ''
8229        '''
8230         Unique identifier of the Resource.
8231        '''
8232        self.name = name if name is not None else ''
8233        '''
8234         Unique human-readable name of the Resource.
8235        '''
8236        self.password = password if password is not None else ''
8237        '''
8238
8239        '''
8240        self.port = port if port is not None else 0
8241        '''
8242
8243        '''
8244        self.port_override = port_override if port_override is not None else 0
8245        '''
8246
8247        '''
8248        self.replica_set = replica_set if replica_set is not None else ''
8249        '''
8250
8251        '''
8252        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8253        '''
8254         ID of the secret store containing credentials for this resource, if any.
8255        '''
8256        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8257        '''
8258         Tags is a map of key, value pairs.
8259        '''
8260        self.tls_required = tls_required if tls_required is not None else False
8261        '''
8262
8263        '''
8264        self.username = username if username is not None else ''
8265        '''
8266
8267        '''
auth_database
bind_interface

Bind interface

connect_to_replica
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
replica_set
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
8289    def to_dict(self):
8290        return {
8291            'auth_database': self.auth_database,
8292            'bind_interface': self.bind_interface,
8293            'connect_to_replica': self.connect_to_replica,
8294            'egress_filter': self.egress_filter,
8295            'healthy': self.healthy,
8296            'hostname': self.hostname,
8297            'id': self.id,
8298            'name': self.name,
8299            'password': self.password,
8300            'port': self.port,
8301            'port_override': self.port_override,
8302            'replica_set': self.replica_set,
8303            'secret_store_id': self.secret_store_id,
8304            'tags': self.tags,
8305            'tls_required': self.tls_required,
8306            'username': self.username,
8307        }
@classmethod
def from_dict(cls, d)
8309    @classmethod
8310    def from_dict(cls, d):
8311        return cls(
8312            auth_database=d.get('auth_database'),
8313            bind_interface=d.get('bind_interface'),
8314            connect_to_replica=d.get('connect_to_replica'),
8315            egress_filter=d.get('egress_filter'),
8316            healthy=d.get('healthy'),
8317            hostname=d.get('hostname'),
8318            id=d.get('id'),
8319            name=d.get('name'),
8320            password=d.get('password'),
8321            port=d.get('port'),
8322            port_override=d.get('port_override'),
8323            replica_set=d.get('replica_set'),
8324            secret_store_id=d.get('secret_store_id'),
8325            tags=d.get('tags'),
8326            tls_required=d.get('tls_required'),
8327            username=d.get('username'),
8328        )
class MongoShardedCluster:
8331class MongoShardedCluster:
8332    '''
8333
8334    '''
8335    __slots__ = [
8336        'auth_database',
8337        'bind_interface',
8338        'egress_filter',
8339        'healthy',
8340        'hostname',
8341        'id',
8342        'name',
8343        'password',
8344        'port_override',
8345        'secret_store_id',
8346        'tags',
8347        'tls_required',
8348        'username',
8349    ]
8350
8351    def __init__(
8352        self,
8353        auth_database=None,
8354        bind_interface=None,
8355        egress_filter=None,
8356        healthy=None,
8357        hostname=None,
8358        id=None,
8359        name=None,
8360        password=None,
8361        port_override=None,
8362        secret_store_id=None,
8363        tags=None,
8364        tls_required=None,
8365        username=None,
8366    ):
8367        self.auth_database = auth_database if auth_database is not None else ''
8368        '''
8369
8370        '''
8371        self.bind_interface = bind_interface if bind_interface is not None else ''
8372        '''
8373         Bind interface
8374        '''
8375        self.egress_filter = egress_filter if egress_filter is not None else ''
8376        '''
8377         A filter applied to the routing logic to pin datasource to nodes.
8378        '''
8379        self.healthy = healthy if healthy is not None else False
8380        '''
8381         True if the datasource is reachable and the credentials are valid.
8382        '''
8383        self.hostname = hostname if hostname is not None else ''
8384        '''
8385
8386        '''
8387        self.id = id if id is not None else ''
8388        '''
8389         Unique identifier of the Resource.
8390        '''
8391        self.name = name if name is not None else ''
8392        '''
8393         Unique human-readable name of the Resource.
8394        '''
8395        self.password = password if password is not None else ''
8396        '''
8397
8398        '''
8399        self.port_override = port_override if port_override is not None else 0
8400        '''
8401
8402        '''
8403        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8404        '''
8405         ID of the secret store containing credentials for this resource, if any.
8406        '''
8407        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8408        '''
8409         Tags is a map of key, value pairs.
8410        '''
8411        self.tls_required = tls_required if tls_required is not None else False
8412        '''
8413
8414        '''
8415        self.username = username if username is not None else ''
8416        '''
8417
8418        '''
8419
8420    def __repr__(self):
8421        return '<sdm.MongoShardedCluster ' + \
8422            'auth_database: ' + repr(self.auth_database) + ' ' +\
8423            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
8424            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
8425            'healthy: ' + repr(self.healthy) + ' ' +\
8426            'hostname: ' + repr(self.hostname) + ' ' +\
8427            'id: ' + repr(self.id) + ' ' +\
8428            'name: ' + repr(self.name) + ' ' +\
8429            'password: ' + repr(self.password) + ' ' +\
8430            'port_override: ' + repr(self.port_override) + ' ' +\
8431            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
8432            'tags: ' + repr(self.tags) + ' ' +\
8433            'tls_required: ' + repr(self.tls_required) + ' ' +\
8434            'username: ' + repr(self.username) + ' ' +\
8435            '>'
8436
8437    def to_dict(self):
8438        return {
8439            'auth_database': self.auth_database,
8440            'bind_interface': self.bind_interface,
8441            'egress_filter': self.egress_filter,
8442            'healthy': self.healthy,
8443            'hostname': self.hostname,
8444            'id': self.id,
8445            'name': self.name,
8446            'password': self.password,
8447            'port_override': self.port_override,
8448            'secret_store_id': self.secret_store_id,
8449            'tags': self.tags,
8450            'tls_required': self.tls_required,
8451            'username': self.username,
8452        }
8453
8454    @classmethod
8455    def from_dict(cls, d):
8456        return cls(
8457            auth_database=d.get('auth_database'),
8458            bind_interface=d.get('bind_interface'),
8459            egress_filter=d.get('egress_filter'),
8460            healthy=d.get('healthy'),
8461            hostname=d.get('hostname'),
8462            id=d.get('id'),
8463            name=d.get('name'),
8464            password=d.get('password'),
8465            port_override=d.get('port_override'),
8466            secret_store_id=d.get('secret_store_id'),
8467            tags=d.get('tags'),
8468            tls_required=d.get('tls_required'),
8469            username=d.get('username'),
8470        )
MongoShardedCluster( auth_database=None, bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port_override=None, secret_store_id=None, tags=None, tls_required=None, username=None)
8351    def __init__(
8352        self,
8353        auth_database=None,
8354        bind_interface=None,
8355        egress_filter=None,
8356        healthy=None,
8357        hostname=None,
8358        id=None,
8359        name=None,
8360        password=None,
8361        port_override=None,
8362        secret_store_id=None,
8363        tags=None,
8364        tls_required=None,
8365        username=None,
8366    ):
8367        self.auth_database = auth_database if auth_database is not None else ''
8368        '''
8369
8370        '''
8371        self.bind_interface = bind_interface if bind_interface is not None else ''
8372        '''
8373         Bind interface
8374        '''
8375        self.egress_filter = egress_filter if egress_filter is not None else ''
8376        '''
8377         A filter applied to the routing logic to pin datasource to nodes.
8378        '''
8379        self.healthy = healthy if healthy is not None else False
8380        '''
8381         True if the datasource is reachable and the credentials are valid.
8382        '''
8383        self.hostname = hostname if hostname is not None else ''
8384        '''
8385
8386        '''
8387        self.id = id if id is not None else ''
8388        '''
8389         Unique identifier of the Resource.
8390        '''
8391        self.name = name if name is not None else ''
8392        '''
8393         Unique human-readable name of the Resource.
8394        '''
8395        self.password = password if password is not None else ''
8396        '''
8397
8398        '''
8399        self.port_override = port_override if port_override is not None else 0
8400        '''
8401
8402        '''
8403        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8404        '''
8405         ID of the secret store containing credentials for this resource, if any.
8406        '''
8407        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8408        '''
8409         Tags is a map of key, value pairs.
8410        '''
8411        self.tls_required = tls_required if tls_required is not None else False
8412        '''
8413
8414        '''
8415        self.username = username if username is not None else ''
8416        '''
8417
8418        '''
auth_database
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
8437    def to_dict(self):
8438        return {
8439            'auth_database': self.auth_database,
8440            'bind_interface': self.bind_interface,
8441            'egress_filter': self.egress_filter,
8442            'healthy': self.healthy,
8443            'hostname': self.hostname,
8444            'id': self.id,
8445            'name': self.name,
8446            'password': self.password,
8447            'port_override': self.port_override,
8448            'secret_store_id': self.secret_store_id,
8449            'tags': self.tags,
8450            'tls_required': self.tls_required,
8451            'username': self.username,
8452        }
@classmethod
def from_dict(cls, d)
8454    @classmethod
8455    def from_dict(cls, d):
8456        return cls(
8457            auth_database=d.get('auth_database'),
8458            bind_interface=d.get('bind_interface'),
8459            egress_filter=d.get('egress_filter'),
8460            healthy=d.get('healthy'),
8461            hostname=d.get('hostname'),
8462            id=d.get('id'),
8463            name=d.get('name'),
8464            password=d.get('password'),
8465            port_override=d.get('port_override'),
8466            secret_store_id=d.get('secret_store_id'),
8467            tags=d.get('tags'),
8468            tls_required=d.get('tls_required'),
8469            username=d.get('username'),
8470        )
class Mysql:
8473class Mysql:
8474    '''
8475
8476    '''
8477    __slots__ = [
8478        'bind_interface',
8479        'database',
8480        'egress_filter',
8481        'healthy',
8482        'hostname',
8483        'id',
8484        'name',
8485        'password',
8486        'port',
8487        'port_override',
8488        'secret_store_id',
8489        'tags',
8490        'username',
8491    ]
8492
8493    def __init__(
8494        self,
8495        bind_interface=None,
8496        database=None,
8497        egress_filter=None,
8498        healthy=None,
8499        hostname=None,
8500        id=None,
8501        name=None,
8502        password=None,
8503        port=None,
8504        port_override=None,
8505        secret_store_id=None,
8506        tags=None,
8507        username=None,
8508    ):
8509        self.bind_interface = bind_interface if bind_interface is not None else ''
8510        '''
8511         Bind interface
8512        '''
8513        self.database = database if database is not None else ''
8514        '''
8515
8516        '''
8517        self.egress_filter = egress_filter if egress_filter is not None else ''
8518        '''
8519         A filter applied to the routing logic to pin datasource to nodes.
8520        '''
8521        self.healthy = healthy if healthy is not None else False
8522        '''
8523         True if the datasource is reachable and the credentials are valid.
8524        '''
8525        self.hostname = hostname if hostname is not None else ''
8526        '''
8527
8528        '''
8529        self.id = id if id is not None else ''
8530        '''
8531         Unique identifier of the Resource.
8532        '''
8533        self.name = name if name is not None else ''
8534        '''
8535         Unique human-readable name of the Resource.
8536        '''
8537        self.password = password if password is not None else ''
8538        '''
8539
8540        '''
8541        self.port = port if port is not None else 0
8542        '''
8543
8544        '''
8545        self.port_override = port_override if port_override is not None else 0
8546        '''
8547
8548        '''
8549        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8550        '''
8551         ID of the secret store containing credentials for this resource, if any.
8552        '''
8553        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8554        '''
8555         Tags is a map of key, value pairs.
8556        '''
8557        self.username = username if username is not None else ''
8558        '''
8559
8560        '''
8561
8562    def __repr__(self):
8563        return '<sdm.Mysql ' + \
8564            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
8565            'database: ' + repr(self.database) + ' ' +\
8566            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
8567            'healthy: ' + repr(self.healthy) + ' ' +\
8568            'hostname: ' + repr(self.hostname) + ' ' +\
8569            'id: ' + repr(self.id) + ' ' +\
8570            'name: ' + repr(self.name) + ' ' +\
8571            'password: ' + repr(self.password) + ' ' +\
8572            'port: ' + repr(self.port) + ' ' +\
8573            'port_override: ' + repr(self.port_override) + ' ' +\
8574            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
8575            'tags: ' + repr(self.tags) + ' ' +\
8576            'username: ' + repr(self.username) + ' ' +\
8577            '>'
8578
8579    def to_dict(self):
8580        return {
8581            'bind_interface': self.bind_interface,
8582            'database': self.database,
8583            'egress_filter': self.egress_filter,
8584            'healthy': self.healthy,
8585            'hostname': self.hostname,
8586            'id': self.id,
8587            'name': self.name,
8588            'password': self.password,
8589            'port': self.port,
8590            'port_override': self.port_override,
8591            'secret_store_id': self.secret_store_id,
8592            'tags': self.tags,
8593            'username': self.username,
8594        }
8595
8596    @classmethod
8597    def from_dict(cls, d):
8598        return cls(
8599            bind_interface=d.get('bind_interface'),
8600            database=d.get('database'),
8601            egress_filter=d.get('egress_filter'),
8602            healthy=d.get('healthy'),
8603            hostname=d.get('hostname'),
8604            id=d.get('id'),
8605            name=d.get('name'),
8606            password=d.get('password'),
8607            port=d.get('port'),
8608            port_override=d.get('port_override'),
8609            secret_store_id=d.get('secret_store_id'),
8610            tags=d.get('tags'),
8611            username=d.get('username'),
8612        )
Mysql( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
8493    def __init__(
8494        self,
8495        bind_interface=None,
8496        database=None,
8497        egress_filter=None,
8498        healthy=None,
8499        hostname=None,
8500        id=None,
8501        name=None,
8502        password=None,
8503        port=None,
8504        port_override=None,
8505        secret_store_id=None,
8506        tags=None,
8507        username=None,
8508    ):
8509        self.bind_interface = bind_interface if bind_interface is not None else ''
8510        '''
8511         Bind interface
8512        '''
8513        self.database = database if database is not None else ''
8514        '''
8515
8516        '''
8517        self.egress_filter = egress_filter if egress_filter is not None else ''
8518        '''
8519         A filter applied to the routing logic to pin datasource to nodes.
8520        '''
8521        self.healthy = healthy if healthy is not None else False
8522        '''
8523         True if the datasource is reachable and the credentials are valid.
8524        '''
8525        self.hostname = hostname if hostname is not None else ''
8526        '''
8527
8528        '''
8529        self.id = id if id is not None else ''
8530        '''
8531         Unique identifier of the Resource.
8532        '''
8533        self.name = name if name is not None else ''
8534        '''
8535         Unique human-readable name of the Resource.
8536        '''
8537        self.password = password if password is not None else ''
8538        '''
8539
8540        '''
8541        self.port = port if port is not None else 0
8542        '''
8543
8544        '''
8545        self.port_override = port_override if port_override is not None else 0
8546        '''
8547
8548        '''
8549        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8550        '''
8551         ID of the secret store containing credentials for this resource, if any.
8552        '''
8553        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8554        '''
8555         Tags is a map of key, value pairs.
8556        '''
8557        self.username = username if username is not None else ''
8558        '''
8559
8560        '''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
8579    def to_dict(self):
8580        return {
8581            'bind_interface': self.bind_interface,
8582            'database': self.database,
8583            'egress_filter': self.egress_filter,
8584            'healthy': self.healthy,
8585            'hostname': self.hostname,
8586            'id': self.id,
8587            'name': self.name,
8588            'password': self.password,
8589            'port': self.port,
8590            'port_override': self.port_override,
8591            'secret_store_id': self.secret_store_id,
8592            'tags': self.tags,
8593            'username': self.username,
8594        }
@classmethod
def from_dict(cls, d)
8596    @classmethod
8597    def from_dict(cls, d):
8598        return cls(
8599            bind_interface=d.get('bind_interface'),
8600            database=d.get('database'),
8601            egress_filter=d.get('egress_filter'),
8602            healthy=d.get('healthy'),
8603            hostname=d.get('hostname'),
8604            id=d.get('id'),
8605            name=d.get('name'),
8606            password=d.get('password'),
8607            port=d.get('port'),
8608            port_override=d.get('port_override'),
8609            secret_store_id=d.get('secret_store_id'),
8610            tags=d.get('tags'),
8611            username=d.get('username'),
8612        )
class Neptune:
8615class Neptune:
8616    '''
8617
8618    '''
8619    __slots__ = [
8620        'bind_interface',
8621        'egress_filter',
8622        'endpoint',
8623        'healthy',
8624        'id',
8625        'name',
8626        'port',
8627        'port_override',
8628        'secret_store_id',
8629        'tags',
8630    ]
8631
8632    def __init__(
8633        self,
8634        bind_interface=None,
8635        egress_filter=None,
8636        endpoint=None,
8637        healthy=None,
8638        id=None,
8639        name=None,
8640        port=None,
8641        port_override=None,
8642        secret_store_id=None,
8643        tags=None,
8644    ):
8645        self.bind_interface = bind_interface if bind_interface is not None else ''
8646        '''
8647         Bind interface
8648        '''
8649        self.egress_filter = egress_filter if egress_filter is not None else ''
8650        '''
8651         A filter applied to the routing logic to pin datasource to nodes.
8652        '''
8653        self.endpoint = endpoint if endpoint is not None else ''
8654        '''
8655
8656        '''
8657        self.healthy = healthy if healthy is not None else False
8658        '''
8659         True if the datasource is reachable and the credentials are valid.
8660        '''
8661        self.id = id if id is not None else ''
8662        '''
8663         Unique identifier of the Resource.
8664        '''
8665        self.name = name if name is not None else ''
8666        '''
8667         Unique human-readable name of the Resource.
8668        '''
8669        self.port = port if port is not None else 0
8670        '''
8671
8672        '''
8673        self.port_override = port_override if port_override is not None else 0
8674        '''
8675
8676        '''
8677        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8678        '''
8679         ID of the secret store containing credentials for this resource, if any.
8680        '''
8681        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8682        '''
8683         Tags is a map of key, value pairs.
8684        '''
8685
8686    def __repr__(self):
8687        return '<sdm.Neptune ' + \
8688            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
8689            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
8690            'endpoint: ' + repr(self.endpoint) + ' ' +\
8691            'healthy: ' + repr(self.healthy) + ' ' +\
8692            'id: ' + repr(self.id) + ' ' +\
8693            'name: ' + repr(self.name) + ' ' +\
8694            'port: ' + repr(self.port) + ' ' +\
8695            'port_override: ' + repr(self.port_override) + ' ' +\
8696            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
8697            'tags: ' + repr(self.tags) + ' ' +\
8698            '>'
8699
8700    def to_dict(self):
8701        return {
8702            'bind_interface': self.bind_interface,
8703            'egress_filter': self.egress_filter,
8704            'endpoint': self.endpoint,
8705            'healthy': self.healthy,
8706            'id': self.id,
8707            'name': self.name,
8708            'port': self.port,
8709            'port_override': self.port_override,
8710            'secret_store_id': self.secret_store_id,
8711            'tags': self.tags,
8712        }
8713
8714    @classmethod
8715    def from_dict(cls, d):
8716        return cls(
8717            bind_interface=d.get('bind_interface'),
8718            egress_filter=d.get('egress_filter'),
8719            endpoint=d.get('endpoint'),
8720            healthy=d.get('healthy'),
8721            id=d.get('id'),
8722            name=d.get('name'),
8723            port=d.get('port'),
8724            port_override=d.get('port_override'),
8725            secret_store_id=d.get('secret_store_id'),
8726            tags=d.get('tags'),
8727        )
Neptune( bind_interface=None, egress_filter=None, endpoint=None, healthy=None, id=None, name=None, port=None, port_override=None, secret_store_id=None, tags=None)
8632    def __init__(
8633        self,
8634        bind_interface=None,
8635        egress_filter=None,
8636        endpoint=None,
8637        healthy=None,
8638        id=None,
8639        name=None,
8640        port=None,
8641        port_override=None,
8642        secret_store_id=None,
8643        tags=None,
8644    ):
8645        self.bind_interface = bind_interface if bind_interface is not None else ''
8646        '''
8647         Bind interface
8648        '''
8649        self.egress_filter = egress_filter if egress_filter is not None else ''
8650        '''
8651         A filter applied to the routing logic to pin datasource to nodes.
8652        '''
8653        self.endpoint = endpoint if endpoint is not None else ''
8654        '''
8655
8656        '''
8657        self.healthy = healthy if healthy is not None else False
8658        '''
8659         True if the datasource is reachable and the credentials are valid.
8660        '''
8661        self.id = id if id is not None else ''
8662        '''
8663         Unique identifier of the Resource.
8664        '''
8665        self.name = name if name is not None else ''
8666        '''
8667         Unique human-readable name of the Resource.
8668        '''
8669        self.port = port if port is not None else 0
8670        '''
8671
8672        '''
8673        self.port_override = port_override if port_override is not None else 0
8674        '''
8675
8676        '''
8677        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8678        '''
8679         ID of the secret store containing credentials for this resource, if any.
8680        '''
8681        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8682        '''
8683         Tags is a map of key, value pairs.
8684        '''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

endpoint
healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
8700    def to_dict(self):
8701        return {
8702            'bind_interface': self.bind_interface,
8703            'egress_filter': self.egress_filter,
8704            'endpoint': self.endpoint,
8705            'healthy': self.healthy,
8706            'id': self.id,
8707            'name': self.name,
8708            'port': self.port,
8709            'port_override': self.port_override,
8710            'secret_store_id': self.secret_store_id,
8711            'tags': self.tags,
8712        }
@classmethod
def from_dict(cls, d)
8714    @classmethod
8715    def from_dict(cls, d):
8716        return cls(
8717            bind_interface=d.get('bind_interface'),
8718            egress_filter=d.get('egress_filter'),
8719            endpoint=d.get('endpoint'),
8720            healthy=d.get('healthy'),
8721            id=d.get('id'),
8722            name=d.get('name'),
8723            port=d.get('port'),
8724            port_override=d.get('port_override'),
8725            secret_store_id=d.get('secret_store_id'),
8726            tags=d.get('tags'),
8727        )
class NeptuneIAM:
8730class NeptuneIAM:
8731    '''
8732
8733    '''
8734    __slots__ = [
8735        'access_key',
8736        'bind_interface',
8737        'egress_filter',
8738        'endpoint',
8739        'healthy',
8740        'id',
8741        'name',
8742        'port',
8743        'port_override',
8744        'region',
8745        'role_arn',
8746        'role_external_id',
8747        'secret_access_key',
8748        'secret_store_id',
8749        'tags',
8750    ]
8751
8752    def __init__(
8753        self,
8754        access_key=None,
8755        bind_interface=None,
8756        egress_filter=None,
8757        endpoint=None,
8758        healthy=None,
8759        id=None,
8760        name=None,
8761        port=None,
8762        port_override=None,
8763        region=None,
8764        role_arn=None,
8765        role_external_id=None,
8766        secret_access_key=None,
8767        secret_store_id=None,
8768        tags=None,
8769    ):
8770        self.access_key = access_key if access_key is not None else ''
8771        '''
8772
8773        '''
8774        self.bind_interface = bind_interface if bind_interface is not None else ''
8775        '''
8776         Bind interface
8777        '''
8778        self.egress_filter = egress_filter if egress_filter is not None else ''
8779        '''
8780         A filter applied to the routing logic to pin datasource to nodes.
8781        '''
8782        self.endpoint = endpoint if endpoint is not None else ''
8783        '''
8784
8785        '''
8786        self.healthy = healthy if healthy is not None else False
8787        '''
8788         True if the datasource is reachable and the credentials are valid.
8789        '''
8790        self.id = id if id is not None else ''
8791        '''
8792         Unique identifier of the Resource.
8793        '''
8794        self.name = name if name is not None else ''
8795        '''
8796         Unique human-readable name of the Resource.
8797        '''
8798        self.port = port if port is not None else 0
8799        '''
8800
8801        '''
8802        self.port_override = port_override if port_override is not None else 0
8803        '''
8804
8805        '''
8806        self.region = region if region is not None else ''
8807        '''
8808
8809        '''
8810        self.role_arn = role_arn if role_arn is not None else ''
8811        '''
8812
8813        '''
8814        self.role_external_id = role_external_id if role_external_id is not None else ''
8815        '''
8816
8817        '''
8818        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
8819        '''
8820
8821        '''
8822        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8823        '''
8824         ID of the secret store containing credentials for this resource, if any.
8825        '''
8826        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8827        '''
8828         Tags is a map of key, value pairs.
8829        '''
8830
8831    def __repr__(self):
8832        return '<sdm.NeptuneIAM ' + \
8833            'access_key: ' + repr(self.access_key) + ' ' +\
8834            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
8835            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
8836            'endpoint: ' + repr(self.endpoint) + ' ' +\
8837            'healthy: ' + repr(self.healthy) + ' ' +\
8838            'id: ' + repr(self.id) + ' ' +\
8839            'name: ' + repr(self.name) + ' ' +\
8840            'port: ' + repr(self.port) + ' ' +\
8841            'port_override: ' + repr(self.port_override) + ' ' +\
8842            'region: ' + repr(self.region) + ' ' +\
8843            'role_arn: ' + repr(self.role_arn) + ' ' +\
8844            'role_external_id: ' + repr(self.role_external_id) + ' ' +\
8845            'secret_access_key: ' + repr(self.secret_access_key) + ' ' +\
8846            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
8847            'tags: ' + repr(self.tags) + ' ' +\
8848            '>'
8849
8850    def to_dict(self):
8851        return {
8852            'access_key': self.access_key,
8853            'bind_interface': self.bind_interface,
8854            'egress_filter': self.egress_filter,
8855            'endpoint': self.endpoint,
8856            'healthy': self.healthy,
8857            'id': self.id,
8858            'name': self.name,
8859            'port': self.port,
8860            'port_override': self.port_override,
8861            'region': self.region,
8862            'role_arn': self.role_arn,
8863            'role_external_id': self.role_external_id,
8864            'secret_access_key': self.secret_access_key,
8865            'secret_store_id': self.secret_store_id,
8866            'tags': self.tags,
8867        }
8868
8869    @classmethod
8870    def from_dict(cls, d):
8871        return cls(
8872            access_key=d.get('access_key'),
8873            bind_interface=d.get('bind_interface'),
8874            egress_filter=d.get('egress_filter'),
8875            endpoint=d.get('endpoint'),
8876            healthy=d.get('healthy'),
8877            id=d.get('id'),
8878            name=d.get('name'),
8879            port=d.get('port'),
8880            port_override=d.get('port_override'),
8881            region=d.get('region'),
8882            role_arn=d.get('role_arn'),
8883            role_external_id=d.get('role_external_id'),
8884            secret_access_key=d.get('secret_access_key'),
8885            secret_store_id=d.get('secret_store_id'),
8886            tags=d.get('tags'),
8887        )
NeptuneIAM( access_key=None, bind_interface=None, egress_filter=None, endpoint=None, healthy=None, id=None, name=None, port=None, port_override=None, region=None, role_arn=None, role_external_id=None, secret_access_key=None, secret_store_id=None, tags=None)
8752    def __init__(
8753        self,
8754        access_key=None,
8755        bind_interface=None,
8756        egress_filter=None,
8757        endpoint=None,
8758        healthy=None,
8759        id=None,
8760        name=None,
8761        port=None,
8762        port_override=None,
8763        region=None,
8764        role_arn=None,
8765        role_external_id=None,
8766        secret_access_key=None,
8767        secret_store_id=None,
8768        tags=None,
8769    ):
8770        self.access_key = access_key if access_key is not None else ''
8771        '''
8772
8773        '''
8774        self.bind_interface = bind_interface if bind_interface is not None else ''
8775        '''
8776         Bind interface
8777        '''
8778        self.egress_filter = egress_filter if egress_filter is not None else ''
8779        '''
8780         A filter applied to the routing logic to pin datasource to nodes.
8781        '''
8782        self.endpoint = endpoint if endpoint is not None else ''
8783        '''
8784
8785        '''
8786        self.healthy = healthy if healthy is not None else False
8787        '''
8788         True if the datasource is reachable and the credentials are valid.
8789        '''
8790        self.id = id if id is not None else ''
8791        '''
8792         Unique identifier of the Resource.
8793        '''
8794        self.name = name if name is not None else ''
8795        '''
8796         Unique human-readable name of the Resource.
8797        '''
8798        self.port = port if port is not None else 0
8799        '''
8800
8801        '''
8802        self.port_override = port_override if port_override is not None else 0
8803        '''
8804
8805        '''
8806        self.region = region if region is not None else ''
8807        '''
8808
8809        '''
8810        self.role_arn = role_arn if role_arn is not None else ''
8811        '''
8812
8813        '''
8814        self.role_external_id = role_external_id if role_external_id is not None else ''
8815        '''
8816
8817        '''
8818        self.secret_access_key = secret_access_key if secret_access_key is not None else ''
8819        '''
8820
8821        '''
8822        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
8823        '''
8824         ID of the secret store containing credentials for this resource, if any.
8825        '''
8826        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
8827        '''
8828         Tags is a map of key, value pairs.
8829        '''
access_key
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

endpoint
healthy

True if the datasource is reachable and the credentials are valid.

id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_override
region
role_arn
role_external_id
secret_access_key
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
8850    def to_dict(self):
8851        return {
8852            'access_key': self.access_key,
8853            'bind_interface': self.bind_interface,
8854            'egress_filter': self.egress_filter,
8855            'endpoint': self.endpoint,
8856            'healthy': self.healthy,
8857            'id': self.id,
8858            'name': self.name,
8859            'port': self.port,
8860            'port_override': self.port_override,
8861            'region': self.region,
8862            'role_arn': self.role_arn,
8863            'role_external_id': self.role_external_id,
8864            'secret_access_key': self.secret_access_key,
8865            'secret_store_id': self.secret_store_id,
8866            'tags': self.tags,
8867        }
@classmethod
def from_dict(cls, d)
8869    @classmethod
8870    def from_dict(cls, d):
8871        return cls(
8872            access_key=d.get('access_key'),
8873            bind_interface=d.get('bind_interface'),
8874            egress_filter=d.get('egress_filter'),
8875            endpoint=d.get('endpoint'),
8876            healthy=d.get('healthy'),
8877            id=d.get('id'),
8878            name=d.get('name'),
8879            port=d.get('port'),
8880            port_override=d.get('port_override'),
8881            region=d.get('region'),
8882            role_arn=d.get('role_arn'),
8883            role_external_id=d.get('role_external_id'),
8884            secret_access_key=d.get('secret_access_key'),
8885            secret_store_id=d.get('secret_store_id'),
8886            tags=d.get('tags'),
8887        )
class NodeCreateResponse:
8890class NodeCreateResponse:
8891    '''
8892     NodeCreateResponse reports how the Nodes were created in the system.
8893    '''
8894    __slots__ = [
8895        'meta',
8896        'node',
8897        'rate_limit',
8898        'token',
8899    ]
8900
8901    def __init__(
8902        self,
8903        meta=None,
8904        node=None,
8905        rate_limit=None,
8906        token=None,
8907    ):
8908        self.meta = meta if meta is not None else None
8909        '''
8910         Reserved for future use.
8911        '''
8912        self.node = node if node is not None else None
8913        '''
8914         The created Node.
8915        '''
8916        self.rate_limit = rate_limit if rate_limit is not None else None
8917        '''
8918         Rate limit information.
8919        '''
8920        self.token = token if token is not None else ''
8921        '''
8922         The auth token generated for the Node. The Node will use this token to
8923         authenticate with the strongDM API.
8924        '''
8925
8926    def __repr__(self):
8927        return '<sdm.NodeCreateResponse ' + \
8928            'meta: ' + repr(self.meta) + ' ' +\
8929            'node: ' + repr(self.node) + ' ' +\
8930            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
8931            'token: ' + repr(self.token) + ' ' +\
8932            '>'
8933
8934    def to_dict(self):
8935        return {
8936            'meta': self.meta,
8937            'node': self.node,
8938            'rate_limit': self.rate_limit,
8939            'token': self.token,
8940        }
8941
8942    @classmethod
8943    def from_dict(cls, d):
8944        return cls(
8945            meta=d.get('meta'),
8946            node=d.get('node'),
8947            rate_limit=d.get('rate_limit'),
8948            token=d.get('token'),
8949        )

NodeCreateResponse reports how the Nodes were created in the system.

NodeCreateResponse(meta=None, node=None, rate_limit=None, token=None)
8901    def __init__(
8902        self,
8903        meta=None,
8904        node=None,
8905        rate_limit=None,
8906        token=None,
8907    ):
8908        self.meta = meta if meta is not None else None
8909        '''
8910         Reserved for future use.
8911        '''
8912        self.node = node if node is not None else None
8913        '''
8914         The created Node.
8915        '''
8916        self.rate_limit = rate_limit if rate_limit is not None else None
8917        '''
8918         Rate limit information.
8919        '''
8920        self.token = token if token is not None else ''
8921        '''
8922         The auth token generated for the Node. The Node will use this token to
8923         authenticate with the strongDM API.
8924        '''
meta

Reserved for future use.

node

The created Node.

rate_limit

Rate limit information.

token

The auth token generated for the Node. The Node will use this token to authenticate with the strongDM API.

def to_dict(self)
8934    def to_dict(self):
8935        return {
8936            'meta': self.meta,
8937            'node': self.node,
8938            'rate_limit': self.rate_limit,
8939            'token': self.token,
8940        }
@classmethod
def from_dict(cls, d)
8942    @classmethod
8943    def from_dict(cls, d):
8944        return cls(
8945            meta=d.get('meta'),
8946            node=d.get('node'),
8947            rate_limit=d.get('rate_limit'),
8948            token=d.get('token'),
8949        )
class NodeDeleteResponse:
8952class NodeDeleteResponse:
8953    '''
8954     NodeDeleteResponse returns information about a Node that was deleted.
8955    '''
8956    __slots__ = [
8957        'meta',
8958        'rate_limit',
8959    ]
8960
8961    def __init__(
8962        self,
8963        meta=None,
8964        rate_limit=None,
8965    ):
8966        self.meta = meta if meta is not None else None
8967        '''
8968         Reserved for future use.
8969        '''
8970        self.rate_limit = rate_limit if rate_limit is not None else None
8971        '''
8972         Rate limit information.
8973        '''
8974
8975    def __repr__(self):
8976        return '<sdm.NodeDeleteResponse ' + \
8977            'meta: ' + repr(self.meta) + ' ' +\
8978            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
8979            '>'
8980
8981    def to_dict(self):
8982        return {
8983            'meta': self.meta,
8984            'rate_limit': self.rate_limit,
8985        }
8986
8987    @classmethod
8988    def from_dict(cls, d):
8989        return cls(
8990            meta=d.get('meta'),
8991            rate_limit=d.get('rate_limit'),
8992        )

NodeDeleteResponse returns information about a Node that was deleted.

NodeDeleteResponse(meta=None, rate_limit=None)
8961    def __init__(
8962        self,
8963        meta=None,
8964        rate_limit=None,
8965    ):
8966        self.meta = meta if meta is not None else None
8967        '''
8968         Reserved for future use.
8969        '''
8970        self.rate_limit = rate_limit if rate_limit is not None else None
8971        '''
8972         Rate limit information.
8973        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
8981    def to_dict(self):
8982        return {
8983            'meta': self.meta,
8984            'rate_limit': self.rate_limit,
8985        }
@classmethod
def from_dict(cls, d)
8987    @classmethod
8988    def from_dict(cls, d):
8989        return cls(
8990            meta=d.get('meta'),
8991            rate_limit=d.get('rate_limit'),
8992        )
class NodeGetResponse:
8995class NodeGetResponse:
8996    '''
8997     NodeGetResponse returns a requested Node.
8998    '''
8999    __slots__ = [
9000        'meta',
9001        'node',
9002        'rate_limit',
9003    ]
9004
9005    def __init__(
9006        self,
9007        meta=None,
9008        node=None,
9009        rate_limit=None,
9010    ):
9011        self.meta = meta if meta is not None else None
9012        '''
9013         Reserved for future use.
9014        '''
9015        self.node = node if node is not None else None
9016        '''
9017         The requested Node.
9018        '''
9019        self.rate_limit = rate_limit if rate_limit is not None else None
9020        '''
9021         Rate limit information.
9022        '''
9023
9024    def __repr__(self):
9025        return '<sdm.NodeGetResponse ' + \
9026            'meta: ' + repr(self.meta) + ' ' +\
9027            'node: ' + repr(self.node) + ' ' +\
9028            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
9029            '>'
9030
9031    def to_dict(self):
9032        return {
9033            'meta': self.meta,
9034            'node': self.node,
9035            'rate_limit': self.rate_limit,
9036        }
9037
9038    @classmethod
9039    def from_dict(cls, d):
9040        return cls(
9041            meta=d.get('meta'),
9042            node=d.get('node'),
9043            rate_limit=d.get('rate_limit'),
9044        )

NodeGetResponse returns a requested Node.

NodeGetResponse(meta=None, node=None, rate_limit=None)
9005    def __init__(
9006        self,
9007        meta=None,
9008        node=None,
9009        rate_limit=None,
9010    ):
9011        self.meta = meta if meta is not None else None
9012        '''
9013         Reserved for future use.
9014        '''
9015        self.node = node if node is not None else None
9016        '''
9017         The requested Node.
9018        '''
9019        self.rate_limit = rate_limit if rate_limit is not None else None
9020        '''
9021         Rate limit information.
9022        '''
meta

Reserved for future use.

node

The requested Node.

rate_limit

Rate limit information.

def to_dict(self)
9031    def to_dict(self):
9032        return {
9033            'meta': self.meta,
9034            'node': self.node,
9035            'rate_limit': self.rate_limit,
9036        }
@classmethod
def from_dict(cls, d)
9038    @classmethod
9039    def from_dict(cls, d):
9040        return cls(
9041            meta=d.get('meta'),
9042            node=d.get('node'),
9043            rate_limit=d.get('rate_limit'),
9044        )
class NodeUpdateResponse:
9047class NodeUpdateResponse:
9048    '''
9049     NodeUpdateResponse returns the fields of a Node after it has been updated by
9050     a NodeUpdateRequest.
9051    '''
9052    __slots__ = [
9053        'meta',
9054        'node',
9055        'rate_limit',
9056    ]
9057
9058    def __init__(
9059        self,
9060        meta=None,
9061        node=None,
9062        rate_limit=None,
9063    ):
9064        self.meta = meta if meta is not None else None
9065        '''
9066         Reserved for future use.
9067        '''
9068        self.node = node if node is not None else None
9069        '''
9070         The updated Node.
9071        '''
9072        self.rate_limit = rate_limit if rate_limit is not None else None
9073        '''
9074         Rate limit information.
9075        '''
9076
9077    def __repr__(self):
9078        return '<sdm.NodeUpdateResponse ' + \
9079            'meta: ' + repr(self.meta) + ' ' +\
9080            'node: ' + repr(self.node) + ' ' +\
9081            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
9082            '>'
9083
9084    def to_dict(self):
9085        return {
9086            'meta': self.meta,
9087            'node': self.node,
9088            'rate_limit': self.rate_limit,
9089        }
9090
9091    @classmethod
9092    def from_dict(cls, d):
9093        return cls(
9094            meta=d.get('meta'),
9095            node=d.get('node'),
9096            rate_limit=d.get('rate_limit'),
9097        )

NodeUpdateResponse returns the fields of a Node after it has been updated by a NodeUpdateRequest.

NodeUpdateResponse(meta=None, node=None, rate_limit=None)
9058    def __init__(
9059        self,
9060        meta=None,
9061        node=None,
9062        rate_limit=None,
9063    ):
9064        self.meta = meta if meta is not None else None
9065        '''
9066         Reserved for future use.
9067        '''
9068        self.node = node if node is not None else None
9069        '''
9070         The updated Node.
9071        '''
9072        self.rate_limit = rate_limit if rate_limit is not None else None
9073        '''
9074         Rate limit information.
9075        '''
meta

Reserved for future use.

node

The updated Node.

rate_limit

Rate limit information.

def to_dict(self)
9084    def to_dict(self):
9085        return {
9086            'meta': self.meta,
9087            'node': self.node,
9088            'rate_limit': self.rate_limit,
9089        }
@classmethod
def from_dict(cls, d)
9091    @classmethod
9092    def from_dict(cls, d):
9093        return cls(
9094            meta=d.get('meta'),
9095            node=d.get('node'),
9096            rate_limit=d.get('rate_limit'),
9097        )
class Oracle:
9100class Oracle:
9101    '''
9102
9103    '''
9104    __slots__ = [
9105        'bind_interface',
9106        'database',
9107        'egress_filter',
9108        'healthy',
9109        'hostname',
9110        'id',
9111        'name',
9112        'password',
9113        'port',
9114        'port_override',
9115        'secret_store_id',
9116        'tags',
9117        'tls_required',
9118        'username',
9119    ]
9120
9121    def __init__(
9122        self,
9123        bind_interface=None,
9124        database=None,
9125        egress_filter=None,
9126        healthy=None,
9127        hostname=None,
9128        id=None,
9129        name=None,
9130        password=None,
9131        port=None,
9132        port_override=None,
9133        secret_store_id=None,
9134        tags=None,
9135        tls_required=None,
9136        username=None,
9137    ):
9138        self.bind_interface = bind_interface if bind_interface is not None else ''
9139        '''
9140         Bind interface
9141        '''
9142        self.database = database if database is not None else ''
9143        '''
9144
9145        '''
9146        self.egress_filter = egress_filter if egress_filter is not None else ''
9147        '''
9148         A filter applied to the routing logic to pin datasource to nodes.
9149        '''
9150        self.healthy = healthy if healthy is not None else False
9151        '''
9152         True if the datasource is reachable and the credentials are valid.
9153        '''
9154        self.hostname = hostname if hostname is not None else ''
9155        '''
9156
9157        '''
9158        self.id = id if id is not None else ''
9159        '''
9160         Unique identifier of the Resource.
9161        '''
9162        self.name = name if name is not None else ''
9163        '''
9164         Unique human-readable name of the Resource.
9165        '''
9166        self.password = password if password is not None else ''
9167        '''
9168
9169        '''
9170        self.port = port if port is not None else 0
9171        '''
9172
9173        '''
9174        self.port_override = port_override if port_override is not None else 0
9175        '''
9176
9177        '''
9178        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
9179        '''
9180         ID of the secret store containing credentials for this resource, if any.
9181        '''
9182        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9183        '''
9184         Tags is a map of key, value pairs.
9185        '''
9186        self.tls_required = tls_required if tls_required is not None else False
9187        '''
9188
9189        '''
9190        self.username = username if username is not None else ''
9191        '''
9192
9193        '''
9194
9195    def __repr__(self):
9196        return '<sdm.Oracle ' + \
9197            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
9198            'database: ' + repr(self.database) + ' ' +\
9199            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
9200            'healthy: ' + repr(self.healthy) + ' ' +\
9201            'hostname: ' + repr(self.hostname) + ' ' +\
9202            'id: ' + repr(self.id) + ' ' +\
9203            'name: ' + repr(self.name) + ' ' +\
9204            'password: ' + repr(self.password) + ' ' +\
9205            'port: ' + repr(self.port) + ' ' +\
9206            'port_override: ' + repr(self.port_override) + ' ' +\
9207            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
9208            'tags: ' + repr(self.tags) + ' ' +\
9209            'tls_required: ' + repr(self.tls_required) + ' ' +\
9210            'username: ' + repr(self.username) + ' ' +\
9211            '>'
9212
9213    def to_dict(self):
9214        return {
9215            'bind_interface': self.bind_interface,
9216            'database': self.database,
9217            'egress_filter': self.egress_filter,
9218            'healthy': self.healthy,
9219            'hostname': self.hostname,
9220            'id': self.id,
9221            'name': self.name,
9222            'password': self.password,
9223            'port': self.port,
9224            'port_override': self.port_override,
9225            'secret_store_id': self.secret_store_id,
9226            'tags': self.tags,
9227            'tls_required': self.tls_required,
9228            'username': self.username,
9229        }
9230
9231    @classmethod
9232    def from_dict(cls, d):
9233        return cls(
9234            bind_interface=d.get('bind_interface'),
9235            database=d.get('database'),
9236            egress_filter=d.get('egress_filter'),
9237            healthy=d.get('healthy'),
9238            hostname=d.get('hostname'),
9239            id=d.get('id'),
9240            name=d.get('name'),
9241            password=d.get('password'),
9242            port=d.get('port'),
9243            port_override=d.get('port_override'),
9244            secret_store_id=d.get('secret_store_id'),
9245            tags=d.get('tags'),
9246            tls_required=d.get('tls_required'),
9247            username=d.get('username'),
9248        )
Oracle( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, tls_required=None, username=None)
9121    def __init__(
9122        self,
9123        bind_interface=None,
9124        database=None,
9125        egress_filter=None,
9126        healthy=None,
9127        hostname=None,
9128        id=None,
9129        name=None,
9130        password=None,
9131        port=None,
9132        port_override=None,
9133        secret_store_id=None,
9134        tags=None,
9135        tls_required=None,
9136        username=None,
9137    ):
9138        self.bind_interface = bind_interface if bind_interface is not None else ''
9139        '''
9140         Bind interface
9141        '''
9142        self.database = database if database is not None else ''
9143        '''
9144
9145        '''
9146        self.egress_filter = egress_filter if egress_filter is not None else ''
9147        '''
9148         A filter applied to the routing logic to pin datasource to nodes.
9149        '''
9150        self.healthy = healthy if healthy is not None else False
9151        '''
9152         True if the datasource is reachable and the credentials are valid.
9153        '''
9154        self.hostname = hostname if hostname is not None else ''
9155        '''
9156
9157        '''
9158        self.id = id if id is not None else ''
9159        '''
9160         Unique identifier of the Resource.
9161        '''
9162        self.name = name if name is not None else ''
9163        '''
9164         Unique human-readable name of the Resource.
9165        '''
9166        self.password = password if password is not None else ''
9167        '''
9168
9169        '''
9170        self.port = port if port is not None else 0
9171        '''
9172
9173        '''
9174        self.port_override = port_override if port_override is not None else 0
9175        '''
9176
9177        '''
9178        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
9179        '''
9180         ID of the secret store containing credentials for this resource, if any.
9181        '''
9182        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9183        '''
9184         Tags is a map of key, value pairs.
9185        '''
9186        self.tls_required = tls_required if tls_required is not None else False
9187        '''
9188
9189        '''
9190        self.username = username if username is not None else ''
9191        '''
9192
9193        '''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
9213    def to_dict(self):
9214        return {
9215            'bind_interface': self.bind_interface,
9216            'database': self.database,
9217            'egress_filter': self.egress_filter,
9218            'healthy': self.healthy,
9219            'hostname': self.hostname,
9220            'id': self.id,
9221            'name': self.name,
9222            'password': self.password,
9223            'port': self.port,
9224            'port_override': self.port_override,
9225            'secret_store_id': self.secret_store_id,
9226            'tags': self.tags,
9227            'tls_required': self.tls_required,
9228            'username': self.username,
9229        }
@classmethod
def from_dict(cls, d)
9231    @classmethod
9232    def from_dict(cls, d):
9233        return cls(
9234            bind_interface=d.get('bind_interface'),
9235            database=d.get('database'),
9236            egress_filter=d.get('egress_filter'),
9237            healthy=d.get('healthy'),
9238            hostname=d.get('hostname'),
9239            id=d.get('id'),
9240            name=d.get('name'),
9241            password=d.get('password'),
9242            port=d.get('port'),
9243            port_override=d.get('port_override'),
9244            secret_store_id=d.get('secret_store_id'),
9245            tags=d.get('tags'),
9246            tls_required=d.get('tls_required'),
9247            username=d.get('username'),
9248        )
class Postgres:
9251class Postgres:
9252    '''
9253
9254    '''
9255    __slots__ = [
9256        'bind_interface',
9257        'database',
9258        'egress_filter',
9259        'healthy',
9260        'hostname',
9261        'id',
9262        'name',
9263        'override_database',
9264        'password',
9265        'port',
9266        'port_override',
9267        'secret_store_id',
9268        'tags',
9269        'username',
9270    ]
9271
9272    def __init__(
9273        self,
9274        bind_interface=None,
9275        database=None,
9276        egress_filter=None,
9277        healthy=None,
9278        hostname=None,
9279        id=None,
9280        name=None,
9281        override_database=None,
9282        password=None,
9283        port=None,
9284        port_override=None,
9285        secret_store_id=None,
9286        tags=None,
9287        username=None,
9288    ):
9289        self.bind_interface = bind_interface if bind_interface is not None else ''
9290        '''
9291         Bind interface
9292        '''
9293        self.database = database if database is not None else ''
9294        '''
9295
9296        '''
9297        self.egress_filter = egress_filter if egress_filter is not None else ''
9298        '''
9299         A filter applied to the routing logic to pin datasource to nodes.
9300        '''
9301        self.healthy = healthy if healthy is not None else False
9302        '''
9303         True if the datasource is reachable and the credentials are valid.
9304        '''
9305        self.hostname = hostname if hostname is not None else ''
9306        '''
9307
9308        '''
9309        self.id = id if id is not None else ''
9310        '''
9311         Unique identifier of the Resource.
9312        '''
9313        self.name = name if name is not None else ''
9314        '''
9315         Unique human-readable name of the Resource.
9316        '''
9317        self.override_database = override_database if override_database is not None else False
9318        '''
9319
9320        '''
9321        self.password = password if password is not None else ''
9322        '''
9323
9324        '''
9325        self.port = port if port is not None else 0
9326        '''
9327
9328        '''
9329        self.port_override = port_override if port_override is not None else 0
9330        '''
9331
9332        '''
9333        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
9334        '''
9335         ID of the secret store containing credentials for this resource, if any.
9336        '''
9337        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9338        '''
9339         Tags is a map of key, value pairs.
9340        '''
9341        self.username = username if username is not None else ''
9342        '''
9343
9344        '''
9345
9346    def __repr__(self):
9347        return '<sdm.Postgres ' + \
9348            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
9349            'database: ' + repr(self.database) + ' ' +\
9350            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
9351            'healthy: ' + repr(self.healthy) + ' ' +\
9352            'hostname: ' + repr(self.hostname) + ' ' +\
9353            'id: ' + repr(self.id) + ' ' +\
9354            'name: ' + repr(self.name) + ' ' +\
9355            'override_database: ' + repr(self.override_database) + ' ' +\
9356            'password: ' + repr(self.password) + ' ' +\
9357            'port: ' + repr(self.port) + ' ' +\
9358            'port_override: ' + repr(self.port_override) + ' ' +\
9359            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
9360            'tags: ' + repr(self.tags) + ' ' +\
9361            'username: ' + repr(self.username) + ' ' +\
9362            '>'
9363
9364    def to_dict(self):
9365        return {
9366            'bind_interface': self.bind_interface,
9367            'database': self.database,
9368            'egress_filter': self.egress_filter,
9369            'healthy': self.healthy,
9370            'hostname': self.hostname,
9371            'id': self.id,
9372            'name': self.name,
9373            'override_database': self.override_database,
9374            'password': self.password,
9375            'port': self.port,
9376            'port_override': self.port_override,
9377            'secret_store_id': self.secret_store_id,
9378            'tags': self.tags,
9379            'username': self.username,
9380        }
9381
9382    @classmethod
9383    def from_dict(cls, d):
9384        return cls(
9385            bind_interface=d.get('bind_interface'),
9386            database=d.get('database'),
9387            egress_filter=d.get('egress_filter'),
9388            healthy=d.get('healthy'),
9389            hostname=d.get('hostname'),
9390            id=d.get('id'),
9391            name=d.get('name'),
9392            override_database=d.get('override_database'),
9393            password=d.get('password'),
9394            port=d.get('port'),
9395            port_override=d.get('port_override'),
9396            secret_store_id=d.get('secret_store_id'),
9397            tags=d.get('tags'),
9398            username=d.get('username'),
9399        )
Postgres( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, override_database=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
9272    def __init__(
9273        self,
9274        bind_interface=None,
9275        database=None,
9276        egress_filter=None,
9277        healthy=None,
9278        hostname=None,
9279        id=None,
9280        name=None,
9281        override_database=None,
9282        password=None,
9283        port=None,
9284        port_override=None,
9285        secret_store_id=None,
9286        tags=None,
9287        username=None,
9288    ):
9289        self.bind_interface = bind_interface if bind_interface is not None else ''
9290        '''
9291         Bind interface
9292        '''
9293        self.database = database if database is not None else ''
9294        '''
9295
9296        '''
9297        self.egress_filter = egress_filter if egress_filter is not None else ''
9298        '''
9299         A filter applied to the routing logic to pin datasource to nodes.
9300        '''
9301        self.healthy = healthy if healthy is not None else False
9302        '''
9303         True if the datasource is reachable and the credentials are valid.
9304        '''
9305        self.hostname = hostname if hostname is not None else ''
9306        '''
9307
9308        '''
9309        self.id = id if id is not None else ''
9310        '''
9311         Unique identifier of the Resource.
9312        '''
9313        self.name = name if name is not None else ''
9314        '''
9315         Unique human-readable name of the Resource.
9316        '''
9317        self.override_database = override_database if override_database is not None else False
9318        '''
9319
9320        '''
9321        self.password = password if password is not None else ''
9322        '''
9323
9324        '''
9325        self.port = port if port is not None else 0
9326        '''
9327
9328        '''
9329        self.port_override = port_override if port_override is not None else 0
9330        '''
9331
9332        '''
9333        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
9334        '''
9335         ID of the secret store containing credentials for this resource, if any.
9336        '''
9337        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9338        '''
9339         Tags is a map of key, value pairs.
9340        '''
9341        self.username = username if username is not None else ''
9342        '''
9343
9344        '''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

override_database
password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
9364    def to_dict(self):
9365        return {
9366            'bind_interface': self.bind_interface,
9367            'database': self.database,
9368            'egress_filter': self.egress_filter,
9369            'healthy': self.healthy,
9370            'hostname': self.hostname,
9371            'id': self.id,
9372            'name': self.name,
9373            'override_database': self.override_database,
9374            'password': self.password,
9375            'port': self.port,
9376            'port_override': self.port_override,
9377            'secret_store_id': self.secret_store_id,
9378            'tags': self.tags,
9379            'username': self.username,
9380        }
@classmethod
def from_dict(cls, d)
9382    @classmethod
9383    def from_dict(cls, d):
9384        return cls(
9385            bind_interface=d.get('bind_interface'),
9386            database=d.get('database'),
9387            egress_filter=d.get('egress_filter'),
9388            healthy=d.get('healthy'),
9389            hostname=d.get('hostname'),
9390            id=d.get('id'),
9391            name=d.get('name'),
9392            override_database=d.get('override_database'),
9393            password=d.get('password'),
9394            port=d.get('port'),
9395            port_override=d.get('port_override'),
9396            secret_store_id=d.get('secret_store_id'),
9397            tags=d.get('tags'),
9398            username=d.get('username'),
9399        )
class Presto:
9402class Presto:
9403    '''
9404
9405    '''
9406    __slots__ = [
9407        'bind_interface',
9408        'database',
9409        'egress_filter',
9410        'healthy',
9411        'hostname',
9412        'id',
9413        'name',
9414        'password',
9415        'port',
9416        'port_override',
9417        'secret_store_id',
9418        'tags',
9419        'tls_required',
9420        'username',
9421    ]
9422
9423    def __init__(
9424        self,
9425        bind_interface=None,
9426        database=None,
9427        egress_filter=None,
9428        healthy=None,
9429        hostname=None,
9430        id=None,
9431        name=None,
9432        password=None,
9433        port=None,
9434        port_override=None,
9435        secret_store_id=None,
9436        tags=None,
9437        tls_required=None,
9438        username=None,
9439    ):
9440        self.bind_interface = bind_interface if bind_interface is not None else ''
9441        '''
9442         Bind interface
9443        '''
9444        self.database = database if database is not None else ''
9445        '''
9446
9447        '''
9448        self.egress_filter = egress_filter if egress_filter is not None else ''
9449        '''
9450         A filter applied to the routing logic to pin datasource to nodes.
9451        '''
9452        self.healthy = healthy if healthy is not None else False
9453        '''
9454         True if the datasource is reachable and the credentials are valid.
9455        '''
9456        self.hostname = hostname if hostname is not None else ''
9457        '''
9458
9459        '''
9460        self.id = id if id is not None else ''
9461        '''
9462         Unique identifier of the Resource.
9463        '''
9464        self.name = name if name is not None else ''
9465        '''
9466         Unique human-readable name of the Resource.
9467        '''
9468        self.password = password if password is not None else ''
9469        '''
9470
9471        '''
9472        self.port = port if port is not None else 0
9473        '''
9474
9475        '''
9476        self.port_override = port_override if port_override is not None else 0
9477        '''
9478
9479        '''
9480        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
9481        '''
9482         ID of the secret store containing credentials for this resource, if any.
9483        '''
9484        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9485        '''
9486         Tags is a map of key, value pairs.
9487        '''
9488        self.tls_required = tls_required if tls_required is not None else False
9489        '''
9490
9491        '''
9492        self.username = username if username is not None else ''
9493        '''
9494
9495        '''
9496
9497    def __repr__(self):
9498        return '<sdm.Presto ' + \
9499            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
9500            'database: ' + repr(self.database) + ' ' +\
9501            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
9502            'healthy: ' + repr(self.healthy) + ' ' +\
9503            'hostname: ' + repr(self.hostname) + ' ' +\
9504            'id: ' + repr(self.id) + ' ' +\
9505            'name: ' + repr(self.name) + ' ' +\
9506            'password: ' + repr(self.password) + ' ' +\
9507            'port: ' + repr(self.port) + ' ' +\
9508            'port_override: ' + repr(self.port_override) + ' ' +\
9509            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
9510            'tags: ' + repr(self.tags) + ' ' +\
9511            'tls_required: ' + repr(self.tls_required) + ' ' +\
9512            'username: ' + repr(self.username) + ' ' +\
9513            '>'
9514
9515    def to_dict(self):
9516        return {
9517            'bind_interface': self.bind_interface,
9518            'database': self.database,
9519            'egress_filter': self.egress_filter,
9520            'healthy': self.healthy,
9521            'hostname': self.hostname,
9522            'id': self.id,
9523            'name': self.name,
9524            'password': self.password,
9525            'port': self.port,
9526            'port_override': self.port_override,
9527            'secret_store_id': self.secret_store_id,
9528            'tags': self.tags,
9529            'tls_required': self.tls_required,
9530            'username': self.username,
9531        }
9532
9533    @classmethod
9534    def from_dict(cls, d):
9535        return cls(
9536            bind_interface=d.get('bind_interface'),
9537            database=d.get('database'),
9538            egress_filter=d.get('egress_filter'),
9539            healthy=d.get('healthy'),
9540            hostname=d.get('hostname'),
9541            id=d.get('id'),
9542            name=d.get('name'),
9543            password=d.get('password'),
9544            port=d.get('port'),
9545            port_override=d.get('port_override'),
9546            secret_store_id=d.get('secret_store_id'),
9547            tags=d.get('tags'),
9548            tls_required=d.get('tls_required'),
9549            username=d.get('username'),
9550        )
Presto( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, tls_required=None, username=None)
9423    def __init__(
9424        self,
9425        bind_interface=None,
9426        database=None,
9427        egress_filter=None,
9428        healthy=None,
9429        hostname=None,
9430        id=None,
9431        name=None,
9432        password=None,
9433        port=None,
9434        port_override=None,
9435        secret_store_id=None,
9436        tags=None,
9437        tls_required=None,
9438        username=None,
9439    ):
9440        self.bind_interface = bind_interface if bind_interface is not None else ''
9441        '''
9442         Bind interface
9443        '''
9444        self.database = database if database is not None else ''
9445        '''
9446
9447        '''
9448        self.egress_filter = egress_filter if egress_filter is not None else ''
9449        '''
9450         A filter applied to the routing logic to pin datasource to nodes.
9451        '''
9452        self.healthy = healthy if healthy is not None else False
9453        '''
9454         True if the datasource is reachable and the credentials are valid.
9455        '''
9456        self.hostname = hostname if hostname is not None else ''
9457        '''
9458
9459        '''
9460        self.id = id if id is not None else ''
9461        '''
9462         Unique identifier of the Resource.
9463        '''
9464        self.name = name if name is not None else ''
9465        '''
9466         Unique human-readable name of the Resource.
9467        '''
9468        self.password = password if password is not None else ''
9469        '''
9470
9471        '''
9472        self.port = port if port is not None else 0
9473        '''
9474
9475        '''
9476        self.port_override = port_override if port_override is not None else 0
9477        '''
9478
9479        '''
9480        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
9481        '''
9482         ID of the secret store containing credentials for this resource, if any.
9483        '''
9484        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9485        '''
9486         Tags is a map of key, value pairs.
9487        '''
9488        self.tls_required = tls_required if tls_required is not None else False
9489        '''
9490
9491        '''
9492        self.username = username if username is not None else ''
9493        '''
9494
9495        '''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
9515    def to_dict(self):
9516        return {
9517            'bind_interface': self.bind_interface,
9518            'database': self.database,
9519            'egress_filter': self.egress_filter,
9520            'healthy': self.healthy,
9521            'hostname': self.hostname,
9522            'id': self.id,
9523            'name': self.name,
9524            'password': self.password,
9525            'port': self.port,
9526            'port_override': self.port_override,
9527            'secret_store_id': self.secret_store_id,
9528            'tags': self.tags,
9529            'tls_required': self.tls_required,
9530            'username': self.username,
9531        }
@classmethod
def from_dict(cls, d)
9533    @classmethod
9534    def from_dict(cls, d):
9535        return cls(
9536            bind_interface=d.get('bind_interface'),
9537            database=d.get('database'),
9538            egress_filter=d.get('egress_filter'),
9539            healthy=d.get('healthy'),
9540            hostname=d.get('hostname'),
9541            id=d.get('id'),
9542            name=d.get('name'),
9543            password=d.get('password'),
9544            port=d.get('port'),
9545            port_override=d.get('port_override'),
9546            secret_store_id=d.get('secret_store_id'),
9547            tags=d.get('tags'),
9548            tls_required=d.get('tls_required'),
9549            username=d.get('username'),
9550        )
class RDP:
9553class RDP:
9554    '''
9555
9556    '''
9557    __slots__ = [
9558        'bind_interface',
9559        'downgrade_nla_connections',
9560        'egress_filter',
9561        'healthy',
9562        'hostname',
9563        'id',
9564        'name',
9565        'password',
9566        'port',
9567        'port_override',
9568        'secret_store_id',
9569        'tags',
9570        'username',
9571    ]
9572
9573    def __init__(
9574        self,
9575        bind_interface=None,
9576        downgrade_nla_connections=None,
9577        egress_filter=None,
9578        healthy=None,
9579        hostname=None,
9580        id=None,
9581        name=None,
9582        password=None,
9583        port=None,
9584        port_override=None,
9585        secret_store_id=None,
9586        tags=None,
9587        username=None,
9588    ):
9589        self.bind_interface = bind_interface if bind_interface is not None else ''
9590        '''
9591         Bind interface
9592        '''
9593        self.downgrade_nla_connections = downgrade_nla_connections if downgrade_nla_connections is not None else False
9594        '''
9595
9596        '''
9597        self.egress_filter = egress_filter if egress_filter is not None else ''
9598        '''
9599         A filter applied to the routing logic to pin datasource to nodes.
9600        '''
9601        self.healthy = healthy if healthy is not None else False
9602        '''
9603         True if the datasource is reachable and the credentials are valid.
9604        '''
9605        self.hostname = hostname if hostname is not None else ''
9606        '''
9607
9608        '''
9609        self.id = id if id is not None else ''
9610        '''
9611         Unique identifier of the Resource.
9612        '''
9613        self.name = name if name is not None else ''
9614        '''
9615         Unique human-readable name of the Resource.
9616        '''
9617        self.password = password if password is not None else ''
9618        '''
9619
9620        '''
9621        self.port = port if port is not None else 0
9622        '''
9623
9624        '''
9625        self.port_override = port_override if port_override is not None else 0
9626        '''
9627
9628        '''
9629        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
9630        '''
9631         ID of the secret store containing credentials for this resource, if any.
9632        '''
9633        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9634        '''
9635         Tags is a map of key, value pairs.
9636        '''
9637        self.username = username if username is not None else ''
9638        '''
9639
9640        '''
9641
9642    def __repr__(self):
9643        return '<sdm.RDP ' + \
9644            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
9645            'downgrade_nla_connections: ' + repr(self.downgrade_nla_connections) + ' ' +\
9646            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
9647            'healthy: ' + repr(self.healthy) + ' ' +\
9648            'hostname: ' + repr(self.hostname) + ' ' +\
9649            'id: ' + repr(self.id) + ' ' +\
9650            'name: ' + repr(self.name) + ' ' +\
9651            'password: ' + repr(self.password) + ' ' +\
9652            'port: ' + repr(self.port) + ' ' +\
9653            'port_override: ' + repr(self.port_override) + ' ' +\
9654            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
9655            'tags: ' + repr(self.tags) + ' ' +\
9656            'username: ' + repr(self.username) + ' ' +\
9657            '>'
9658
9659    def to_dict(self):
9660        return {
9661            'bind_interface': self.bind_interface,
9662            'downgrade_nla_connections': self.downgrade_nla_connections,
9663            'egress_filter': self.egress_filter,
9664            'healthy': self.healthy,
9665            'hostname': self.hostname,
9666            'id': self.id,
9667            'name': self.name,
9668            'password': self.password,
9669            'port': self.port,
9670            'port_override': self.port_override,
9671            'secret_store_id': self.secret_store_id,
9672            'tags': self.tags,
9673            'username': self.username,
9674        }
9675
9676    @classmethod
9677    def from_dict(cls, d):
9678        return cls(
9679            bind_interface=d.get('bind_interface'),
9680            downgrade_nla_connections=d.get('downgrade_nla_connections'),
9681            egress_filter=d.get('egress_filter'),
9682            healthy=d.get('healthy'),
9683            hostname=d.get('hostname'),
9684            id=d.get('id'),
9685            name=d.get('name'),
9686            password=d.get('password'),
9687            port=d.get('port'),
9688            port_override=d.get('port_override'),
9689            secret_store_id=d.get('secret_store_id'),
9690            tags=d.get('tags'),
9691            username=d.get('username'),
9692        )
RDP( bind_interface=None, downgrade_nla_connections=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
9573    def __init__(
9574        self,
9575        bind_interface=None,
9576        downgrade_nla_connections=None,
9577        egress_filter=None,
9578        healthy=None,
9579        hostname=None,
9580        id=None,
9581        name=None,
9582        password=None,
9583        port=None,
9584        port_override=None,
9585        secret_store_id=None,
9586        tags=None,
9587        username=None,
9588    ):
9589        self.bind_interface = bind_interface if bind_interface is not None else ''
9590        '''
9591         Bind interface
9592        '''
9593        self.downgrade_nla_connections = downgrade_nla_connections if downgrade_nla_connections is not None else False
9594        '''
9595
9596        '''
9597        self.egress_filter = egress_filter if egress_filter is not None else ''
9598        '''
9599         A filter applied to the routing logic to pin datasource to nodes.
9600        '''
9601        self.healthy = healthy if healthy is not None else False
9602        '''
9603         True if the datasource is reachable and the credentials are valid.
9604        '''
9605        self.hostname = hostname if hostname is not None else ''
9606        '''
9607
9608        '''
9609        self.id = id if id is not None else ''
9610        '''
9611         Unique identifier of the Resource.
9612        '''
9613        self.name = name if name is not None else ''
9614        '''
9615         Unique human-readable name of the Resource.
9616        '''
9617        self.password = password if password is not None else ''
9618        '''
9619
9620        '''
9621        self.port = port if port is not None else 0
9622        '''
9623
9624        '''
9625        self.port_override = port_override if port_override is not None else 0
9626        '''
9627
9628        '''
9629        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
9630        '''
9631         ID of the secret store containing credentials for this resource, if any.
9632        '''
9633        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9634        '''
9635         Tags is a map of key, value pairs.
9636        '''
9637        self.username = username if username is not None else ''
9638        '''
9639
9640        '''
bind_interface

Bind interface

downgrade_nla_connections
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
9659    def to_dict(self):
9660        return {
9661            'bind_interface': self.bind_interface,
9662            'downgrade_nla_connections': self.downgrade_nla_connections,
9663            'egress_filter': self.egress_filter,
9664            'healthy': self.healthy,
9665            'hostname': self.hostname,
9666            'id': self.id,
9667            'name': self.name,
9668            'password': self.password,
9669            'port': self.port,
9670            'port_override': self.port_override,
9671            'secret_store_id': self.secret_store_id,
9672            'tags': self.tags,
9673            'username': self.username,
9674        }
@classmethod
def from_dict(cls, d)
9676    @classmethod
9677    def from_dict(cls, d):
9678        return cls(
9679            bind_interface=d.get('bind_interface'),
9680            downgrade_nla_connections=d.get('downgrade_nla_connections'),
9681            egress_filter=d.get('egress_filter'),
9682            healthy=d.get('healthy'),
9683            hostname=d.get('hostname'),
9684            id=d.get('id'),
9685            name=d.get('name'),
9686            password=d.get('password'),
9687            port=d.get('port'),
9688            port_override=d.get('port_override'),
9689            secret_store_id=d.get('secret_store_id'),
9690            tags=d.get('tags'),
9691            username=d.get('username'),
9692        )
class RabbitMQAMQP091:
9695class RabbitMQAMQP091:
9696    '''
9697
9698    '''
9699    __slots__ = [
9700        'bind_interface',
9701        'egress_filter',
9702        'healthy',
9703        'hostname',
9704        'id',
9705        'name',
9706        'password',
9707        'port',
9708        'port_override',
9709        'secret_store_id',
9710        'tags',
9711        'tls_required',
9712        'username',
9713    ]
9714
9715    def __init__(
9716        self,
9717        bind_interface=None,
9718        egress_filter=None,
9719        healthy=None,
9720        hostname=None,
9721        id=None,
9722        name=None,
9723        password=None,
9724        port=None,
9725        port_override=None,
9726        secret_store_id=None,
9727        tags=None,
9728        tls_required=None,
9729        username=None,
9730    ):
9731        self.bind_interface = bind_interface if bind_interface is not None else ''
9732        '''
9733         Bind interface
9734        '''
9735        self.egress_filter = egress_filter if egress_filter is not None else ''
9736        '''
9737         A filter applied to the routing logic to pin datasource to nodes.
9738        '''
9739        self.healthy = healthy if healthy is not None else False
9740        '''
9741         True if the datasource is reachable and the credentials are valid.
9742        '''
9743        self.hostname = hostname if hostname is not None else ''
9744        '''
9745
9746        '''
9747        self.id = id if id is not None else ''
9748        '''
9749         Unique identifier of the Resource.
9750        '''
9751        self.name = name if name is not None else ''
9752        '''
9753         Unique human-readable name of the Resource.
9754        '''
9755        self.password = password if password is not None else ''
9756        '''
9757
9758        '''
9759        self.port = port if port is not None else 0
9760        '''
9761
9762        '''
9763        self.port_override = port_override if port_override is not None else 0
9764        '''
9765
9766        '''
9767        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
9768        '''
9769         ID of the secret store containing credentials for this resource, if any.
9770        '''
9771        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9772        '''
9773         Tags is a map of key, value pairs.
9774        '''
9775        self.tls_required = tls_required if tls_required is not None else False
9776        '''
9777
9778        '''
9779        self.username = username if username is not None else ''
9780        '''
9781
9782        '''
9783
9784    def __repr__(self):
9785        return '<sdm.RabbitMQAMQP091 ' + \
9786            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
9787            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
9788            'healthy: ' + repr(self.healthy) + ' ' +\
9789            'hostname: ' + repr(self.hostname) + ' ' +\
9790            'id: ' + repr(self.id) + ' ' +\
9791            'name: ' + repr(self.name) + ' ' +\
9792            'password: ' + repr(self.password) + ' ' +\
9793            'port: ' + repr(self.port) + ' ' +\
9794            'port_override: ' + repr(self.port_override) + ' ' +\
9795            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
9796            'tags: ' + repr(self.tags) + ' ' +\
9797            'tls_required: ' + repr(self.tls_required) + ' ' +\
9798            'username: ' + repr(self.username) + ' ' +\
9799            '>'
9800
9801    def to_dict(self):
9802        return {
9803            'bind_interface': self.bind_interface,
9804            'egress_filter': self.egress_filter,
9805            'healthy': self.healthy,
9806            'hostname': self.hostname,
9807            'id': self.id,
9808            'name': self.name,
9809            'password': self.password,
9810            'port': self.port,
9811            'port_override': self.port_override,
9812            'secret_store_id': self.secret_store_id,
9813            'tags': self.tags,
9814            'tls_required': self.tls_required,
9815            'username': self.username,
9816        }
9817
9818    @classmethod
9819    def from_dict(cls, d):
9820        return cls(
9821            bind_interface=d.get('bind_interface'),
9822            egress_filter=d.get('egress_filter'),
9823            healthy=d.get('healthy'),
9824            hostname=d.get('hostname'),
9825            id=d.get('id'),
9826            name=d.get('name'),
9827            password=d.get('password'),
9828            port=d.get('port'),
9829            port_override=d.get('port_override'),
9830            secret_store_id=d.get('secret_store_id'),
9831            tags=d.get('tags'),
9832            tls_required=d.get('tls_required'),
9833            username=d.get('username'),
9834        )
RabbitMQAMQP091( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, tls_required=None, username=None)
9715    def __init__(
9716        self,
9717        bind_interface=None,
9718        egress_filter=None,
9719        healthy=None,
9720        hostname=None,
9721        id=None,
9722        name=None,
9723        password=None,
9724        port=None,
9725        port_override=None,
9726        secret_store_id=None,
9727        tags=None,
9728        tls_required=None,
9729        username=None,
9730    ):
9731        self.bind_interface = bind_interface if bind_interface is not None else ''
9732        '''
9733         Bind interface
9734        '''
9735        self.egress_filter = egress_filter if egress_filter is not None else ''
9736        '''
9737         A filter applied to the routing logic to pin datasource to nodes.
9738        '''
9739        self.healthy = healthy if healthy is not None else False
9740        '''
9741         True if the datasource is reachable and the credentials are valid.
9742        '''
9743        self.hostname = hostname if hostname is not None else ''
9744        '''
9745
9746        '''
9747        self.id = id if id is not None else ''
9748        '''
9749         Unique identifier of the Resource.
9750        '''
9751        self.name = name if name is not None else ''
9752        '''
9753         Unique human-readable name of the Resource.
9754        '''
9755        self.password = password if password is not None else ''
9756        '''
9757
9758        '''
9759        self.port = port if port is not None else 0
9760        '''
9761
9762        '''
9763        self.port_override = port_override if port_override is not None else 0
9764        '''
9765
9766        '''
9767        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
9768        '''
9769         ID of the secret store containing credentials for this resource, if any.
9770        '''
9771        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9772        '''
9773         Tags is a map of key, value pairs.
9774        '''
9775        self.tls_required = tls_required if tls_required is not None else False
9776        '''
9777
9778        '''
9779        self.username = username if username is not None else ''
9780        '''
9781
9782        '''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

tls_required
username
def to_dict(self)
9801    def to_dict(self):
9802        return {
9803            'bind_interface': self.bind_interface,
9804            'egress_filter': self.egress_filter,
9805            'healthy': self.healthy,
9806            'hostname': self.hostname,
9807            'id': self.id,
9808            'name': self.name,
9809            'password': self.password,
9810            'port': self.port,
9811            'port_override': self.port_override,
9812            'secret_store_id': self.secret_store_id,
9813            'tags': self.tags,
9814            'tls_required': self.tls_required,
9815            'username': self.username,
9816        }
@classmethod
def from_dict(cls, d)
9818    @classmethod
9819    def from_dict(cls, d):
9820        return cls(
9821            bind_interface=d.get('bind_interface'),
9822            egress_filter=d.get('egress_filter'),
9823            healthy=d.get('healthy'),
9824            hostname=d.get('hostname'),
9825            id=d.get('id'),
9826            name=d.get('name'),
9827            password=d.get('password'),
9828            port=d.get('port'),
9829            port_override=d.get('port_override'),
9830            secret_store_id=d.get('secret_store_id'),
9831            tags=d.get('tags'),
9832            tls_required=d.get('tls_required'),
9833            username=d.get('username'),
9834        )
class RateLimitMetadata:
9837class RateLimitMetadata:
9838    '''
9839     RateLimitMetadata contains information about remaining requests avaialable
9840     to the user over some timeframe.
9841    '''
9842    __slots__ = [
9843        'bucket',
9844        'limit',
9845        'remaining',
9846        'reset_at',
9847    ]
9848
9849    def __init__(
9850        self,
9851        bucket=None,
9852        limit=None,
9853        remaining=None,
9854        reset_at=None,
9855    ):
9856        self.bucket = bucket if bucket is not None else ''
9857        '''
9858         The bucket this user/token is associated with, which may be shared between
9859         multiple users/tokens.
9860        '''
9861        self.limit = limit if limit is not None else 0
9862        '''
9863         How many total requests the user/token is authorized to make before being
9864         rate limited.
9865        '''
9866        self.remaining = remaining if remaining is not None else 0
9867        '''
9868         How many remaining requests out of the limit are still avaialable.
9869        '''
9870        self.reset_at = reset_at if reset_at is not None else None
9871        '''
9872         The time when remaining will be reset to limit.
9873        '''
9874
9875    def __repr__(self):
9876        return '<sdm.RateLimitMetadata ' + \
9877            'bucket: ' + repr(self.bucket) + ' ' +\
9878            'limit: ' + repr(self.limit) + ' ' +\
9879            'remaining: ' + repr(self.remaining) + ' ' +\
9880            'reset_at: ' + repr(self.reset_at) + ' ' +\
9881            '>'
9882
9883    def to_dict(self):
9884        return {
9885            'bucket': self.bucket,
9886            'limit': self.limit,
9887            'remaining': self.remaining,
9888            'reset_at': self.reset_at,
9889        }
9890
9891    @classmethod
9892    def from_dict(cls, d):
9893        return cls(
9894            bucket=d.get('bucket'),
9895            limit=d.get('limit'),
9896            remaining=d.get('remaining'),
9897            reset_at=d.get('reset_at'),
9898        )

RateLimitMetadata contains information about remaining requests avaialable to the user over some timeframe.

RateLimitMetadata(bucket=None, limit=None, remaining=None, reset_at=None)
9849    def __init__(
9850        self,
9851        bucket=None,
9852        limit=None,
9853        remaining=None,
9854        reset_at=None,
9855    ):
9856        self.bucket = bucket if bucket is not None else ''
9857        '''
9858         The bucket this user/token is associated with, which may be shared between
9859         multiple users/tokens.
9860        '''
9861        self.limit = limit if limit is not None else 0
9862        '''
9863         How many total requests the user/token is authorized to make before being
9864         rate limited.
9865        '''
9866        self.remaining = remaining if remaining is not None else 0
9867        '''
9868         How many remaining requests out of the limit are still avaialable.
9869        '''
9870        self.reset_at = reset_at if reset_at is not None else None
9871        '''
9872         The time when remaining will be reset to limit.
9873        '''
bucket

The bucket this user/token is associated with, which may be shared between multiple users/tokens.

limit

How many total requests the user/token is authorized to make before being rate limited.

remaining

How many remaining requests out of the limit are still avaialable.

reset_at

The time when remaining will be reset to limit.

def to_dict(self)
9883    def to_dict(self):
9884        return {
9885            'bucket': self.bucket,
9886            'limit': self.limit,
9887            'remaining': self.remaining,
9888            'reset_at': self.reset_at,
9889        }
@classmethod
def from_dict(cls, d)
9891    @classmethod
9892    def from_dict(cls, d):
9893        return cls(
9894            bucket=d.get('bucket'),
9895            limit=d.get('limit'),
9896            remaining=d.get('remaining'),
9897            reset_at=d.get('reset_at'),
9898        )
class RawTCP:
 9901class RawTCP:
 9902    '''
 9903
 9904    '''
 9905    __slots__ = [
 9906        'bind_interface',
 9907        'egress_filter',
 9908        'healthy',
 9909        'hostname',
 9910        'id',
 9911        'name',
 9912        'port',
 9913        'port_override',
 9914        'secret_store_id',
 9915        'tags',
 9916    ]
 9917
 9918    def __init__(
 9919        self,
 9920        bind_interface=None,
 9921        egress_filter=None,
 9922        healthy=None,
 9923        hostname=None,
 9924        id=None,
 9925        name=None,
 9926        port=None,
 9927        port_override=None,
 9928        secret_store_id=None,
 9929        tags=None,
 9930    ):
 9931        self.bind_interface = bind_interface if bind_interface is not None else ''
 9932        '''
 9933         Bind interface
 9934        '''
 9935        self.egress_filter = egress_filter if egress_filter is not None else ''
 9936        '''
 9937         A filter applied to the routing logic to pin datasource to nodes.
 9938        '''
 9939        self.healthy = healthy if healthy is not None else False
 9940        '''
 9941         True if the datasource is reachable and the credentials are valid.
 9942        '''
 9943        self.hostname = hostname if hostname is not None else ''
 9944        '''
 9945
 9946        '''
 9947        self.id = id if id is not None else ''
 9948        '''
 9949         Unique identifier of the Resource.
 9950        '''
 9951        self.name = name if name is not None else ''
 9952        '''
 9953         Unique human-readable name of the Resource.
 9954        '''
 9955        self.port = port if port is not None else 0
 9956        '''
 9957
 9958        '''
 9959        self.port_override = port_override if port_override is not None else 0
 9960        '''
 9961
 9962        '''
 9963        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
 9964        '''
 9965         ID of the secret store containing credentials for this resource, if any.
 9966        '''
 9967        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
 9968        '''
 9969         Tags is a map of key, value pairs.
 9970        '''
 9971
 9972    def __repr__(self):
 9973        return '<sdm.RawTCP ' + \
 9974            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
 9975            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
 9976            'healthy: ' + repr(self.healthy) + ' ' +\
 9977            'hostname: ' + repr(self.hostname) + ' ' +\
 9978            'id: ' + repr(self.id) + ' ' +\
 9979            'name: ' + repr(self.name) + ' ' +\
 9980            'port: ' + repr(self.port) + ' ' +\
 9981            'port_override: ' + repr(self.port_override) + ' ' +\
 9982            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
 9983            'tags: ' + repr(self.tags) + ' ' +\
 9984            '>'
 9985
 9986    def to_dict(self):
 9987        return {
 9988            'bind_interface': self.bind_interface,
 9989            'egress_filter': self.egress_filter,
 9990            'healthy': self.healthy,
 9991            'hostname': self.hostname,
 9992            'id': self.id,
 9993            'name': self.name,
 9994            'port': self.port,
 9995            'port_override': self.port_override,
 9996            'secret_store_id': self.secret_store_id,
 9997            'tags': self.tags,
 9998        }
 9999
10000    @classmethod
10001    def from_dict(cls, d):
10002        return cls(
10003            bind_interface=d.get('bind_interface'),
10004            egress_filter=d.get('egress_filter'),
10005            healthy=d.get('healthy'),
10006            hostname=d.get('hostname'),
10007            id=d.get('id'),
10008            name=d.get('name'),
10009            port=d.get('port'),
10010            port_override=d.get('port_override'),
10011            secret_store_id=d.get('secret_store_id'),
10012            tags=d.get('tags'),
10013        )
RawTCP( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, port=None, port_override=None, secret_store_id=None, tags=None)
9918    def __init__(
9919        self,
9920        bind_interface=None,
9921        egress_filter=None,
9922        healthy=None,
9923        hostname=None,
9924        id=None,
9925        name=None,
9926        port=None,
9927        port_override=None,
9928        secret_store_id=None,
9929        tags=None,
9930    ):
9931        self.bind_interface = bind_interface if bind_interface is not None else ''
9932        '''
9933         Bind interface
9934        '''
9935        self.egress_filter = egress_filter if egress_filter is not None else ''
9936        '''
9937         A filter applied to the routing logic to pin datasource to nodes.
9938        '''
9939        self.healthy = healthy if healthy is not None else False
9940        '''
9941         True if the datasource is reachable and the credentials are valid.
9942        '''
9943        self.hostname = hostname if hostname is not None else ''
9944        '''
9945
9946        '''
9947        self.id = id if id is not None else ''
9948        '''
9949         Unique identifier of the Resource.
9950        '''
9951        self.name = name if name is not None else ''
9952        '''
9953         Unique human-readable name of the Resource.
9954        '''
9955        self.port = port if port is not None else 0
9956        '''
9957
9958        '''
9959        self.port_override = port_override if port_override is not None else 0
9960        '''
9961
9962        '''
9963        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
9964        '''
9965         ID of the secret store containing credentials for this resource, if any.
9966        '''
9967        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
9968        '''
9969         Tags is a map of key, value pairs.
9970        '''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
9986    def to_dict(self):
9987        return {
9988            'bind_interface': self.bind_interface,
9989            'egress_filter': self.egress_filter,
9990            'healthy': self.healthy,
9991            'hostname': self.hostname,
9992            'id': self.id,
9993            'name': self.name,
9994            'port': self.port,
9995            'port_override': self.port_override,
9996            'secret_store_id': self.secret_store_id,
9997            'tags': self.tags,
9998        }
@classmethod
def from_dict(cls, d)
10000    @classmethod
10001    def from_dict(cls, d):
10002        return cls(
10003            bind_interface=d.get('bind_interface'),
10004            egress_filter=d.get('egress_filter'),
10005            healthy=d.get('healthy'),
10006            hostname=d.get('hostname'),
10007            id=d.get('id'),
10008            name=d.get('name'),
10009            port=d.get('port'),
10010            port_override=d.get('port_override'),
10011            secret_store_id=d.get('secret_store_id'),
10012            tags=d.get('tags'),
10013        )
class Redis:
10016class Redis:
10017    '''
10018
10019    '''
10020    __slots__ = [
10021        'bind_interface',
10022        'egress_filter',
10023        'healthy',
10024        'hostname',
10025        'id',
10026        'name',
10027        'password',
10028        'port',
10029        'port_override',
10030        'secret_store_id',
10031        'tags',
10032    ]
10033
10034    def __init__(
10035        self,
10036        bind_interface=None,
10037        egress_filter=None,
10038        healthy=None,
10039        hostname=None,
10040        id=None,
10041        name=None,
10042        password=None,
10043        port=None,
10044        port_override=None,
10045        secret_store_id=None,
10046        tags=None,
10047    ):
10048        self.bind_interface = bind_interface if bind_interface is not None else ''
10049        '''
10050         Bind interface
10051        '''
10052        self.egress_filter = egress_filter if egress_filter is not None else ''
10053        '''
10054         A filter applied to the routing logic to pin datasource to nodes.
10055        '''
10056        self.healthy = healthy if healthy is not None else False
10057        '''
10058         True if the datasource is reachable and the credentials are valid.
10059        '''
10060        self.hostname = hostname if hostname is not None else ''
10061        '''
10062
10063        '''
10064        self.id = id if id is not None else ''
10065        '''
10066         Unique identifier of the Resource.
10067        '''
10068        self.name = name if name is not None else ''
10069        '''
10070         Unique human-readable name of the Resource.
10071        '''
10072        self.password = password if password is not None else ''
10073        '''
10074
10075        '''
10076        self.port = port if port is not None else 0
10077        '''
10078
10079        '''
10080        self.port_override = port_override if port_override is not None else 0
10081        '''
10082
10083        '''
10084        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
10085        '''
10086         ID of the secret store containing credentials for this resource, if any.
10087        '''
10088        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10089        '''
10090         Tags is a map of key, value pairs.
10091        '''
10092
10093    def __repr__(self):
10094        return '<sdm.Redis ' + \
10095            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
10096            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
10097            'healthy: ' + repr(self.healthy) + ' ' +\
10098            'hostname: ' + repr(self.hostname) + ' ' +\
10099            'id: ' + repr(self.id) + ' ' +\
10100            'name: ' + repr(self.name) + ' ' +\
10101            'password: ' + repr(self.password) + ' ' +\
10102            'port: ' + repr(self.port) + ' ' +\
10103            'port_override: ' + repr(self.port_override) + ' ' +\
10104            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
10105            'tags: ' + repr(self.tags) + ' ' +\
10106            '>'
10107
10108    def to_dict(self):
10109        return {
10110            'bind_interface': self.bind_interface,
10111            'egress_filter': self.egress_filter,
10112            'healthy': self.healthy,
10113            'hostname': self.hostname,
10114            'id': self.id,
10115            'name': self.name,
10116            'password': self.password,
10117            'port': self.port,
10118            'port_override': self.port_override,
10119            'secret_store_id': self.secret_store_id,
10120            'tags': self.tags,
10121        }
10122
10123    @classmethod
10124    def from_dict(cls, d):
10125        return cls(
10126            bind_interface=d.get('bind_interface'),
10127            egress_filter=d.get('egress_filter'),
10128            healthy=d.get('healthy'),
10129            hostname=d.get('hostname'),
10130            id=d.get('id'),
10131            name=d.get('name'),
10132            password=d.get('password'),
10133            port=d.get('port'),
10134            port_override=d.get('port_override'),
10135            secret_store_id=d.get('secret_store_id'),
10136            tags=d.get('tags'),
10137        )
Redis( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None)
10034    def __init__(
10035        self,
10036        bind_interface=None,
10037        egress_filter=None,
10038        healthy=None,
10039        hostname=None,
10040        id=None,
10041        name=None,
10042        password=None,
10043        port=None,
10044        port_override=None,
10045        secret_store_id=None,
10046        tags=None,
10047    ):
10048        self.bind_interface = bind_interface if bind_interface is not None else ''
10049        '''
10050         Bind interface
10051        '''
10052        self.egress_filter = egress_filter if egress_filter is not None else ''
10053        '''
10054         A filter applied to the routing logic to pin datasource to nodes.
10055        '''
10056        self.healthy = healthy if healthy is not None else False
10057        '''
10058         True if the datasource is reachable and the credentials are valid.
10059        '''
10060        self.hostname = hostname if hostname is not None else ''
10061        '''
10062
10063        '''
10064        self.id = id if id is not None else ''
10065        '''
10066         Unique identifier of the Resource.
10067        '''
10068        self.name = name if name is not None else ''
10069        '''
10070         Unique human-readable name of the Resource.
10071        '''
10072        self.password = password if password is not None else ''
10073        '''
10074
10075        '''
10076        self.port = port if port is not None else 0
10077        '''
10078
10079        '''
10080        self.port_override = port_override if port_override is not None else 0
10081        '''
10082
10083        '''
10084        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
10085        '''
10086         ID of the secret store containing credentials for this resource, if any.
10087        '''
10088        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10089        '''
10090         Tags is a map of key, value pairs.
10091        '''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

def to_dict(self)
10108    def to_dict(self):
10109        return {
10110            'bind_interface': self.bind_interface,
10111            'egress_filter': self.egress_filter,
10112            'healthy': self.healthy,
10113            'hostname': self.hostname,
10114            'id': self.id,
10115            'name': self.name,
10116            'password': self.password,
10117            'port': self.port,
10118            'port_override': self.port_override,
10119            'secret_store_id': self.secret_store_id,
10120            'tags': self.tags,
10121        }
@classmethod
def from_dict(cls, d)
10123    @classmethod
10124    def from_dict(cls, d):
10125        return cls(
10126            bind_interface=d.get('bind_interface'),
10127            egress_filter=d.get('egress_filter'),
10128            healthy=d.get('healthy'),
10129            hostname=d.get('hostname'),
10130            id=d.get('id'),
10131            name=d.get('name'),
10132            password=d.get('password'),
10133            port=d.get('port'),
10134            port_override=d.get('port_override'),
10135            secret_store_id=d.get('secret_store_id'),
10136            tags=d.get('tags'),
10137        )
class Redshift:
10140class Redshift:
10141    '''
10142
10143    '''
10144    __slots__ = [
10145        'bind_interface',
10146        'database',
10147        'egress_filter',
10148        'healthy',
10149        'hostname',
10150        'id',
10151        'name',
10152        'override_database',
10153        'password',
10154        'port',
10155        'port_override',
10156        'secret_store_id',
10157        'tags',
10158        'username',
10159    ]
10160
10161    def __init__(
10162        self,
10163        bind_interface=None,
10164        database=None,
10165        egress_filter=None,
10166        healthy=None,
10167        hostname=None,
10168        id=None,
10169        name=None,
10170        override_database=None,
10171        password=None,
10172        port=None,
10173        port_override=None,
10174        secret_store_id=None,
10175        tags=None,
10176        username=None,
10177    ):
10178        self.bind_interface = bind_interface if bind_interface is not None else ''
10179        '''
10180         Bind interface
10181        '''
10182        self.database = database if database is not None else ''
10183        '''
10184
10185        '''
10186        self.egress_filter = egress_filter if egress_filter is not None else ''
10187        '''
10188         A filter applied to the routing logic to pin datasource to nodes.
10189        '''
10190        self.healthy = healthy if healthy is not None else False
10191        '''
10192         True if the datasource is reachable and the credentials are valid.
10193        '''
10194        self.hostname = hostname if hostname is not None else ''
10195        '''
10196
10197        '''
10198        self.id = id if id is not None else ''
10199        '''
10200         Unique identifier of the Resource.
10201        '''
10202        self.name = name if name is not None else ''
10203        '''
10204         Unique human-readable name of the Resource.
10205        '''
10206        self.override_database = override_database if override_database is not None else False
10207        '''
10208
10209        '''
10210        self.password = password if password is not None else ''
10211        '''
10212
10213        '''
10214        self.port = port if port is not None else 0
10215        '''
10216
10217        '''
10218        self.port_override = port_override if port_override is not None else 0
10219        '''
10220
10221        '''
10222        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
10223        '''
10224         ID of the secret store containing credentials for this resource, if any.
10225        '''
10226        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10227        '''
10228         Tags is a map of key, value pairs.
10229        '''
10230        self.username = username if username is not None else ''
10231        '''
10232
10233        '''
10234
10235    def __repr__(self):
10236        return '<sdm.Redshift ' + \
10237            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
10238            'database: ' + repr(self.database) + ' ' +\
10239            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
10240            'healthy: ' + repr(self.healthy) + ' ' +\
10241            'hostname: ' + repr(self.hostname) + ' ' +\
10242            'id: ' + repr(self.id) + ' ' +\
10243            'name: ' + repr(self.name) + ' ' +\
10244            'override_database: ' + repr(self.override_database) + ' ' +\
10245            'password: ' + repr(self.password) + ' ' +\
10246            'port: ' + repr(self.port) + ' ' +\
10247            'port_override: ' + repr(self.port_override) + ' ' +\
10248            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
10249            'tags: ' + repr(self.tags) + ' ' +\
10250            'username: ' + repr(self.username) + ' ' +\
10251            '>'
10252
10253    def to_dict(self):
10254        return {
10255            'bind_interface': self.bind_interface,
10256            'database': self.database,
10257            'egress_filter': self.egress_filter,
10258            'healthy': self.healthy,
10259            'hostname': self.hostname,
10260            'id': self.id,
10261            'name': self.name,
10262            'override_database': self.override_database,
10263            'password': self.password,
10264            'port': self.port,
10265            'port_override': self.port_override,
10266            'secret_store_id': self.secret_store_id,
10267            'tags': self.tags,
10268            'username': self.username,
10269        }
10270
10271    @classmethod
10272    def from_dict(cls, d):
10273        return cls(
10274            bind_interface=d.get('bind_interface'),
10275            database=d.get('database'),
10276            egress_filter=d.get('egress_filter'),
10277            healthy=d.get('healthy'),
10278            hostname=d.get('hostname'),
10279            id=d.get('id'),
10280            name=d.get('name'),
10281            override_database=d.get('override_database'),
10282            password=d.get('password'),
10283            port=d.get('port'),
10284            port_override=d.get('port_override'),
10285            secret_store_id=d.get('secret_store_id'),
10286            tags=d.get('tags'),
10287            username=d.get('username'),
10288        )
Redshift( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, override_database=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
10161    def __init__(
10162        self,
10163        bind_interface=None,
10164        database=None,
10165        egress_filter=None,
10166        healthy=None,
10167        hostname=None,
10168        id=None,
10169        name=None,
10170        override_database=None,
10171        password=None,
10172        port=None,
10173        port_override=None,
10174        secret_store_id=None,
10175        tags=None,
10176        username=None,
10177    ):
10178        self.bind_interface = bind_interface if bind_interface is not None else ''
10179        '''
10180         Bind interface
10181        '''
10182        self.database = database if database is not None else ''
10183        '''
10184
10185        '''
10186        self.egress_filter = egress_filter if egress_filter is not None else ''
10187        '''
10188         A filter applied to the routing logic to pin datasource to nodes.
10189        '''
10190        self.healthy = healthy if healthy is not None else False
10191        '''
10192         True if the datasource is reachable and the credentials are valid.
10193        '''
10194        self.hostname = hostname if hostname is not None else ''
10195        '''
10196
10197        '''
10198        self.id = id if id is not None else ''
10199        '''
10200         Unique identifier of the Resource.
10201        '''
10202        self.name = name if name is not None else ''
10203        '''
10204         Unique human-readable name of the Resource.
10205        '''
10206        self.override_database = override_database if override_database is not None else False
10207        '''
10208
10209        '''
10210        self.password = password if password is not None else ''
10211        '''
10212
10213        '''
10214        self.port = port if port is not None else 0
10215        '''
10216
10217        '''
10218        self.port_override = port_override if port_override is not None else 0
10219        '''
10220
10221        '''
10222        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
10223        '''
10224         ID of the secret store containing credentials for this resource, if any.
10225        '''
10226        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10227        '''
10228         Tags is a map of key, value pairs.
10229        '''
10230        self.username = username if username is not None else ''
10231        '''
10232
10233        '''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

override_database
password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
10253    def to_dict(self):
10254        return {
10255            'bind_interface': self.bind_interface,
10256            'database': self.database,
10257            'egress_filter': self.egress_filter,
10258            'healthy': self.healthy,
10259            'hostname': self.hostname,
10260            'id': self.id,
10261            'name': self.name,
10262            'override_database': self.override_database,
10263            'password': self.password,
10264            'port': self.port,
10265            'port_override': self.port_override,
10266            'secret_store_id': self.secret_store_id,
10267            'tags': self.tags,
10268            'username': self.username,
10269        }
@classmethod
def from_dict(cls, d)
10271    @classmethod
10272    def from_dict(cls, d):
10273        return cls(
10274            bind_interface=d.get('bind_interface'),
10275            database=d.get('database'),
10276            egress_filter=d.get('egress_filter'),
10277            healthy=d.get('healthy'),
10278            hostname=d.get('hostname'),
10279            id=d.get('id'),
10280            name=d.get('name'),
10281            override_database=d.get('override_database'),
10282            password=d.get('password'),
10283            port=d.get('port'),
10284            port_override=d.get('port_override'),
10285            secret_store_id=d.get('secret_store_id'),
10286            tags=d.get('tags'),
10287            username=d.get('username'),
10288        )
class Relay:
10291class Relay:
10292    '''
10293     Relay represents a StrongDM CLI installation running in relay mode.
10294    '''
10295    __slots__ = [
10296        'gateway_filter',
10297        'id',
10298        'name',
10299        'state',
10300        'tags',
10301    ]
10302
10303    def __init__(
10304        self,
10305        gateway_filter=None,
10306        id=None,
10307        name=None,
10308        state=None,
10309        tags=None,
10310    ):
10311        self.gateway_filter = gateway_filter if gateway_filter is not None else ''
10312        '''
10313         GatewayFilter can be used to restrict the peering between relays and
10314         gateways.
10315        '''
10316        self.id = id if id is not None else ''
10317        '''
10318         Unique identifier of the Relay.
10319        '''
10320        self.name = name if name is not None else ''
10321        '''
10322         Unique human-readable name of the Relay. Node names must include only letters, numbers, and hyphens (no spaces, underscores, or other special characters). Generated if not provided on create.
10323        '''
10324        self.state = state if state is not None else ''
10325        '''
10326         The current state of the relay. One of: "new", "verifying_restart",
10327         "awaiting_restart", "restarting", "started", "stopped", "dead",
10328         "unknown".
10329        '''
10330        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10331        '''
10332         Tags is a map of key, value pairs.
10333        '''
10334
10335    def __repr__(self):
10336        return '<sdm.Relay ' + \
10337            'gateway_filter: ' + repr(self.gateway_filter) + ' ' +\
10338            'id: ' + repr(self.id) + ' ' +\
10339            'name: ' + repr(self.name) + ' ' +\
10340            'state: ' + repr(self.state) + ' ' +\
10341            'tags: ' + repr(self.tags) + ' ' +\
10342            '>'
10343
10344    def to_dict(self):
10345        return {
10346            'gateway_filter': self.gateway_filter,
10347            'id': self.id,
10348            'name': self.name,
10349            'state': self.state,
10350            'tags': self.tags,
10351        }
10352
10353    @classmethod
10354    def from_dict(cls, d):
10355        return cls(
10356            gateway_filter=d.get('gateway_filter'),
10357            id=d.get('id'),
10358            name=d.get('name'),
10359            state=d.get('state'),
10360            tags=d.get('tags'),
10361        )

Relay represents a StrongDM CLI installation running in relay mode.

Relay(gateway_filter=None, id=None, name=None, state=None, tags=None)
10303    def __init__(
10304        self,
10305        gateway_filter=None,
10306        id=None,
10307        name=None,
10308        state=None,
10309        tags=None,
10310    ):
10311        self.gateway_filter = gateway_filter if gateway_filter is not None else ''
10312        '''
10313         GatewayFilter can be used to restrict the peering between relays and
10314         gateways.
10315        '''
10316        self.id = id if id is not None else ''
10317        '''
10318         Unique identifier of the Relay.
10319        '''
10320        self.name = name if name is not None else ''
10321        '''
10322         Unique human-readable name of the Relay. Node names must include only letters, numbers, and hyphens (no spaces, underscores, or other special characters). Generated if not provided on create.
10323        '''
10324        self.state = state if state is not None else ''
10325        '''
10326         The current state of the relay. One of: "new", "verifying_restart",
10327         "awaiting_restart", "restarting", "started", "stopped", "dead",
10328         "unknown".
10329        '''
10330        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10331        '''
10332         Tags is a map of key, value pairs.
10333        '''
gateway_filter

GatewayFilter can be used to restrict the peering between relays and gateways.

id

Unique identifier of the Relay.

name

Unique human-readable name of the Relay. Node names must include only letters, numbers, and hyphens (no spaces, underscores, or other special characters). Generated if not provided on create.

state

The current state of the relay. One of: "new", "verifying_restart", "awaiting_restart", "restarting", "started", "stopped", "dead", "unknown".

tags

Tags is a map of key, value pairs.

def to_dict(self)
10344    def to_dict(self):
10345        return {
10346            'gateway_filter': self.gateway_filter,
10347            'id': self.id,
10348            'name': self.name,
10349            'state': self.state,
10350            'tags': self.tags,
10351        }
@classmethod
def from_dict(cls, d)
10353    @classmethod
10354    def from_dict(cls, d):
10355        return cls(
10356            gateway_filter=d.get('gateway_filter'),
10357            id=d.get('id'),
10358            name=d.get('name'),
10359            state=d.get('state'),
10360            tags=d.get('tags'),
10361        )
class RemoteIdentity:
10364class RemoteIdentity:
10365    '''
10366     RemoteIdentities define the username to be used for a specific account
10367     when connecting to a remote resource using that group.
10368    '''
10369    __slots__ = [
10370        'account_id',
10371        'id',
10372        'remote_identity_group_id',
10373        'username',
10374    ]
10375
10376    def __init__(
10377        self,
10378        account_id=None,
10379        id=None,
10380        remote_identity_group_id=None,
10381        username=None,
10382    ):
10383        self.account_id = account_id if account_id is not None else ''
10384        '''
10385         The account for this remote identity.
10386        '''
10387        self.id = id if id is not None else ''
10388        '''
10389         Unique identifier of the RemoteIdentity.
10390        '''
10391        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
10392        '''
10393         The remote identity group.
10394        '''
10395        self.username = username if username is not None else ''
10396        '''
10397         The username to be used as the remote identity for this account.
10398        '''
10399
10400    def __repr__(self):
10401        return '<sdm.RemoteIdentity ' + \
10402            'account_id: ' + repr(self.account_id) + ' ' +\
10403            'id: ' + repr(self.id) + ' ' +\
10404            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
10405            'username: ' + repr(self.username) + ' ' +\
10406            '>'
10407
10408    def to_dict(self):
10409        return {
10410            'account_id': self.account_id,
10411            'id': self.id,
10412            'remote_identity_group_id': self.remote_identity_group_id,
10413            'username': self.username,
10414        }
10415
10416    @classmethod
10417    def from_dict(cls, d):
10418        return cls(
10419            account_id=d.get('account_id'),
10420            id=d.get('id'),
10421            remote_identity_group_id=d.get('remote_identity_group_id'),
10422            username=d.get('username'),
10423        )

RemoteIdentities define the username to be used for a specific account when connecting to a remote resource using that group.

RemoteIdentity( account_id=None, id=None, remote_identity_group_id=None, username=None)
10376    def __init__(
10377        self,
10378        account_id=None,
10379        id=None,
10380        remote_identity_group_id=None,
10381        username=None,
10382    ):
10383        self.account_id = account_id if account_id is not None else ''
10384        '''
10385         The account for this remote identity.
10386        '''
10387        self.id = id if id is not None else ''
10388        '''
10389         Unique identifier of the RemoteIdentity.
10390        '''
10391        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
10392        '''
10393         The remote identity group.
10394        '''
10395        self.username = username if username is not None else ''
10396        '''
10397         The username to be used as the remote identity for this account.
10398        '''
account_id

The account for this remote identity.

id

Unique identifier of the RemoteIdentity.

remote_identity_group_id

The remote identity group.

username

The username to be used as the remote identity for this account.

def to_dict(self)
10408    def to_dict(self):
10409        return {
10410            'account_id': self.account_id,
10411            'id': self.id,
10412            'remote_identity_group_id': self.remote_identity_group_id,
10413            'username': self.username,
10414        }
@classmethod
def from_dict(cls, d)
10416    @classmethod
10417    def from_dict(cls, d):
10418        return cls(
10419            account_id=d.get('account_id'),
10420            id=d.get('id'),
10421            remote_identity_group_id=d.get('remote_identity_group_id'),
10422            username=d.get('username'),
10423        )
class RemoteIdentityCreateResponse:
10426class RemoteIdentityCreateResponse:
10427    '''
10428     RemoteIdentityCreateResponse reports how the RemoteIdentities were created in the system.
10429    '''
10430    __slots__ = [
10431        'meta',
10432        'rate_limit',
10433        'remote_identity',
10434    ]
10435
10436    def __init__(
10437        self,
10438        meta=None,
10439        rate_limit=None,
10440        remote_identity=None,
10441    ):
10442        self.meta = meta if meta is not None else None
10443        '''
10444         Reserved for future use.
10445        '''
10446        self.rate_limit = rate_limit if rate_limit is not None else None
10447        '''
10448         Rate limit information.
10449        '''
10450        self.remote_identity = remote_identity if remote_identity is not None else None
10451        '''
10452         The created RemoteIdentity.
10453        '''
10454
10455    def __repr__(self):
10456        return '<sdm.RemoteIdentityCreateResponse ' + \
10457            'meta: ' + repr(self.meta) + ' ' +\
10458            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10459            'remote_identity: ' + repr(self.remote_identity) + ' ' +\
10460            '>'
10461
10462    def to_dict(self):
10463        return {
10464            'meta': self.meta,
10465            'rate_limit': self.rate_limit,
10466            'remote_identity': self.remote_identity,
10467        }
10468
10469    @classmethod
10470    def from_dict(cls, d):
10471        return cls(
10472            meta=d.get('meta'),
10473            rate_limit=d.get('rate_limit'),
10474            remote_identity=d.get('remote_identity'),
10475        )

RemoteIdentityCreateResponse reports how the RemoteIdentities were created in the system.

RemoteIdentityCreateResponse(meta=None, rate_limit=None, remote_identity=None)
10436    def __init__(
10437        self,
10438        meta=None,
10439        rate_limit=None,
10440        remote_identity=None,
10441    ):
10442        self.meta = meta if meta is not None else None
10443        '''
10444         Reserved for future use.
10445        '''
10446        self.rate_limit = rate_limit if rate_limit is not None else None
10447        '''
10448         Rate limit information.
10449        '''
10450        self.remote_identity = remote_identity if remote_identity is not None else None
10451        '''
10452         The created RemoteIdentity.
10453        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

remote_identity

The created RemoteIdentity.

def to_dict(self)
10462    def to_dict(self):
10463        return {
10464            'meta': self.meta,
10465            'rate_limit': self.rate_limit,
10466            'remote_identity': self.remote_identity,
10467        }
@classmethod
def from_dict(cls, d)
10469    @classmethod
10470    def from_dict(cls, d):
10471        return cls(
10472            meta=d.get('meta'),
10473            rate_limit=d.get('rate_limit'),
10474            remote_identity=d.get('remote_identity'),
10475        )
class RemoteIdentityDeleteResponse:
10478class RemoteIdentityDeleteResponse:
10479    '''
10480     RemoteIdentityDeleteResponse returns information about a RemoteIdentity that was deleted.
10481    '''
10482    __slots__ = [
10483        'meta',
10484        'rate_limit',
10485    ]
10486
10487    def __init__(
10488        self,
10489        meta=None,
10490        rate_limit=None,
10491    ):
10492        self.meta = meta if meta is not None else None
10493        '''
10494         Reserved for future use.
10495        '''
10496        self.rate_limit = rate_limit if rate_limit is not None else None
10497        '''
10498         Rate limit information.
10499        '''
10500
10501    def __repr__(self):
10502        return '<sdm.RemoteIdentityDeleteResponse ' + \
10503            'meta: ' + repr(self.meta) + ' ' +\
10504            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10505            '>'
10506
10507    def to_dict(self):
10508        return {
10509            'meta': self.meta,
10510            'rate_limit': self.rate_limit,
10511        }
10512
10513    @classmethod
10514    def from_dict(cls, d):
10515        return cls(
10516            meta=d.get('meta'),
10517            rate_limit=d.get('rate_limit'),
10518        )

RemoteIdentityDeleteResponse returns information about a RemoteIdentity that was deleted.

RemoteIdentityDeleteResponse(meta=None, rate_limit=None)
10487    def __init__(
10488        self,
10489        meta=None,
10490        rate_limit=None,
10491    ):
10492        self.meta = meta if meta is not None else None
10493        '''
10494         Reserved for future use.
10495        '''
10496        self.rate_limit = rate_limit if rate_limit is not None else None
10497        '''
10498         Rate limit information.
10499        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
10507    def to_dict(self):
10508        return {
10509            'meta': self.meta,
10510            'rate_limit': self.rate_limit,
10511        }
@classmethod
def from_dict(cls, d)
10513    @classmethod
10514    def from_dict(cls, d):
10515        return cls(
10516            meta=d.get('meta'),
10517            rate_limit=d.get('rate_limit'),
10518        )
class RemoteIdentityGetResponse:
10521class RemoteIdentityGetResponse:
10522    '''
10523     RemoteIdentityGetResponse returns a requested RemoteIdentity.
10524    '''
10525    __slots__ = [
10526        'meta',
10527        'rate_limit',
10528        'remote_identity',
10529    ]
10530
10531    def __init__(
10532        self,
10533        meta=None,
10534        rate_limit=None,
10535        remote_identity=None,
10536    ):
10537        self.meta = meta if meta is not None else None
10538        '''
10539         Reserved for future use.
10540        '''
10541        self.rate_limit = rate_limit if rate_limit is not None else None
10542        '''
10543         Rate limit information.
10544        '''
10545        self.remote_identity = remote_identity if remote_identity is not None else None
10546        '''
10547         The requested RemoteIdentity.
10548        '''
10549
10550    def __repr__(self):
10551        return '<sdm.RemoteIdentityGetResponse ' + \
10552            'meta: ' + repr(self.meta) + ' ' +\
10553            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10554            'remote_identity: ' + repr(self.remote_identity) + ' ' +\
10555            '>'
10556
10557    def to_dict(self):
10558        return {
10559            'meta': self.meta,
10560            'rate_limit': self.rate_limit,
10561            'remote_identity': self.remote_identity,
10562        }
10563
10564    @classmethod
10565    def from_dict(cls, d):
10566        return cls(
10567            meta=d.get('meta'),
10568            rate_limit=d.get('rate_limit'),
10569            remote_identity=d.get('remote_identity'),
10570        )

RemoteIdentityGetResponse returns a requested RemoteIdentity.

RemoteIdentityGetResponse(meta=None, rate_limit=None, remote_identity=None)
10531    def __init__(
10532        self,
10533        meta=None,
10534        rate_limit=None,
10535        remote_identity=None,
10536    ):
10537        self.meta = meta if meta is not None else None
10538        '''
10539         Reserved for future use.
10540        '''
10541        self.rate_limit = rate_limit if rate_limit is not None else None
10542        '''
10543         Rate limit information.
10544        '''
10545        self.remote_identity = remote_identity if remote_identity is not None else None
10546        '''
10547         The requested RemoteIdentity.
10548        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

remote_identity

The requested RemoteIdentity.

def to_dict(self)
10557    def to_dict(self):
10558        return {
10559            'meta': self.meta,
10560            'rate_limit': self.rate_limit,
10561            'remote_identity': self.remote_identity,
10562        }
@classmethod
def from_dict(cls, d)
10564    @classmethod
10565    def from_dict(cls, d):
10566        return cls(
10567            meta=d.get('meta'),
10568            rate_limit=d.get('rate_limit'),
10569            remote_identity=d.get('remote_identity'),
10570        )
class RemoteIdentityGroup:
10573class RemoteIdentityGroup:
10574    '''
10575     A RemoteIdentityGroup defines a group of remote identities.
10576    '''
10577    __slots__ = [
10578        'id',
10579        'name',
10580    ]
10581
10582    def __init__(
10583        self,
10584        id=None,
10585        name=None,
10586    ):
10587        self.id = id if id is not None else ''
10588        '''
10589         Unique identifier of the RemoteIdentityGroup.
10590        '''
10591        self.name = name if name is not None else ''
10592        '''
10593         Unique human-readable name of the RemoteIdentityGroup.
10594        '''
10595
10596    def __repr__(self):
10597        return '<sdm.RemoteIdentityGroup ' + \
10598            'id: ' + repr(self.id) + ' ' +\
10599            'name: ' + repr(self.name) + ' ' +\
10600            '>'
10601
10602    def to_dict(self):
10603        return {
10604            'id': self.id,
10605            'name': self.name,
10606        }
10607
10608    @classmethod
10609    def from_dict(cls, d):
10610        return cls(
10611            id=d.get('id'),
10612            name=d.get('name'),
10613        )

A RemoteIdentityGroup defines a group of remote identities.

RemoteIdentityGroup(id=None, name=None)
10582    def __init__(
10583        self,
10584        id=None,
10585        name=None,
10586    ):
10587        self.id = id if id is not None else ''
10588        '''
10589         Unique identifier of the RemoteIdentityGroup.
10590        '''
10591        self.name = name if name is not None else ''
10592        '''
10593         Unique human-readable name of the RemoteIdentityGroup.
10594        '''
id

Unique identifier of the RemoteIdentityGroup.

name

Unique human-readable name of the RemoteIdentityGroup.

def to_dict(self)
10602    def to_dict(self):
10603        return {
10604            'id': self.id,
10605            'name': self.name,
10606        }
@classmethod
def from_dict(cls, d)
10608    @classmethod
10609    def from_dict(cls, d):
10610        return cls(
10611            id=d.get('id'),
10612            name=d.get('name'),
10613        )
class RemoteIdentityGroupGetResponse:
10616class RemoteIdentityGroupGetResponse:
10617    '''
10618     RemoteIdentityGroupGetResponse returns a requested RemoteIdentityGroup.
10619    '''
10620    __slots__ = [
10621        'meta',
10622        'rate_limit',
10623        'remote_identity_group',
10624    ]
10625
10626    def __init__(
10627        self,
10628        meta=None,
10629        rate_limit=None,
10630        remote_identity_group=None,
10631    ):
10632        self.meta = meta if meta is not None else None
10633        '''
10634         Reserved for future use.
10635        '''
10636        self.rate_limit = rate_limit if rate_limit is not None else None
10637        '''
10638         Rate limit information.
10639        '''
10640        self.remote_identity_group = remote_identity_group if remote_identity_group is not None else None
10641        '''
10642         The requested RemoteIdentityGroup.
10643        '''
10644
10645    def __repr__(self):
10646        return '<sdm.RemoteIdentityGroupGetResponse ' + \
10647            'meta: ' + repr(self.meta) + ' ' +\
10648            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10649            'remote_identity_group: ' + repr(self.remote_identity_group) + ' ' +\
10650            '>'
10651
10652    def to_dict(self):
10653        return {
10654            'meta': self.meta,
10655            'rate_limit': self.rate_limit,
10656            'remote_identity_group': self.remote_identity_group,
10657        }
10658
10659    @classmethod
10660    def from_dict(cls, d):
10661        return cls(
10662            meta=d.get('meta'),
10663            rate_limit=d.get('rate_limit'),
10664            remote_identity_group=d.get('remote_identity_group'),
10665        )

RemoteIdentityGroupGetResponse returns a requested RemoteIdentityGroup.

RemoteIdentityGroupGetResponse(meta=None, rate_limit=None, remote_identity_group=None)
10626    def __init__(
10627        self,
10628        meta=None,
10629        rate_limit=None,
10630        remote_identity_group=None,
10631    ):
10632        self.meta = meta if meta is not None else None
10633        '''
10634         Reserved for future use.
10635        '''
10636        self.rate_limit = rate_limit if rate_limit is not None else None
10637        '''
10638         Rate limit information.
10639        '''
10640        self.remote_identity_group = remote_identity_group if remote_identity_group is not None else None
10641        '''
10642         The requested RemoteIdentityGroup.
10643        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

remote_identity_group

The requested RemoteIdentityGroup.

def to_dict(self)
10652    def to_dict(self):
10653        return {
10654            'meta': self.meta,
10655            'rate_limit': self.rate_limit,
10656            'remote_identity_group': self.remote_identity_group,
10657        }
@classmethod
def from_dict(cls, d)
10659    @classmethod
10660    def from_dict(cls, d):
10661        return cls(
10662            meta=d.get('meta'),
10663            rate_limit=d.get('rate_limit'),
10664            remote_identity_group=d.get('remote_identity_group'),
10665        )
class RemoteIdentityUpdateResponse:
10668class RemoteIdentityUpdateResponse:
10669    '''
10670     RemoteIdentityUpdateResponse returns the fields of a RemoteIdentity after it has been updated by
10671     a RemoteIdentityUpdateRequest.
10672    '''
10673    __slots__ = [
10674        'meta',
10675        'rate_limit',
10676        'remote_identity',
10677    ]
10678
10679    def __init__(
10680        self,
10681        meta=None,
10682        rate_limit=None,
10683        remote_identity=None,
10684    ):
10685        self.meta = meta if meta is not None else None
10686        '''
10687         Reserved for future use.
10688        '''
10689        self.rate_limit = rate_limit if rate_limit is not None else None
10690        '''
10691         Rate limit information.
10692        '''
10693        self.remote_identity = remote_identity if remote_identity is not None else None
10694        '''
10695         The updated RemoteIdentity.
10696        '''
10697
10698    def __repr__(self):
10699        return '<sdm.RemoteIdentityUpdateResponse ' + \
10700            'meta: ' + repr(self.meta) + ' ' +\
10701            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10702            'remote_identity: ' + repr(self.remote_identity) + ' ' +\
10703            '>'
10704
10705    def to_dict(self):
10706        return {
10707            'meta': self.meta,
10708            'rate_limit': self.rate_limit,
10709            'remote_identity': self.remote_identity,
10710        }
10711
10712    @classmethod
10713    def from_dict(cls, d):
10714        return cls(
10715            meta=d.get('meta'),
10716            rate_limit=d.get('rate_limit'),
10717            remote_identity=d.get('remote_identity'),
10718        )

RemoteIdentityUpdateResponse returns the fields of a RemoteIdentity after it has been updated by a RemoteIdentityUpdateRequest.

RemoteIdentityUpdateResponse(meta=None, rate_limit=None, remote_identity=None)
10679    def __init__(
10680        self,
10681        meta=None,
10682        rate_limit=None,
10683        remote_identity=None,
10684    ):
10685        self.meta = meta if meta is not None else None
10686        '''
10687         Reserved for future use.
10688        '''
10689        self.rate_limit = rate_limit if rate_limit is not None else None
10690        '''
10691         Rate limit information.
10692        '''
10693        self.remote_identity = remote_identity if remote_identity is not None else None
10694        '''
10695         The updated RemoteIdentity.
10696        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

remote_identity

The updated RemoteIdentity.

def to_dict(self)
10705    def to_dict(self):
10706        return {
10707            'meta': self.meta,
10708            'rate_limit': self.rate_limit,
10709            'remote_identity': self.remote_identity,
10710        }
@classmethod
def from_dict(cls, d)
10712    @classmethod
10713    def from_dict(cls, d):
10714        return cls(
10715            meta=d.get('meta'),
10716            rate_limit=d.get('rate_limit'),
10717            remote_identity=d.get('remote_identity'),
10718        )
class ResourceCreateResponse:
10721class ResourceCreateResponse:
10722    '''
10723     ResourceCreateResponse reports how the Resources were created in the system.
10724    '''
10725    __slots__ = [
10726        'meta',
10727        'rate_limit',
10728        'resource',
10729    ]
10730
10731    def __init__(
10732        self,
10733        meta=None,
10734        rate_limit=None,
10735        resource=None,
10736    ):
10737        self.meta = meta if meta is not None else None
10738        '''
10739         Reserved for future use.
10740        '''
10741        self.rate_limit = rate_limit if rate_limit is not None else None
10742        '''
10743         Rate limit information.
10744        '''
10745        self.resource = resource if resource is not None else None
10746        '''
10747         The created Resource.
10748        '''
10749
10750    def __repr__(self):
10751        return '<sdm.ResourceCreateResponse ' + \
10752            'meta: ' + repr(self.meta) + ' ' +\
10753            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10754            'resource: ' + repr(self.resource) + ' ' +\
10755            '>'
10756
10757    def to_dict(self):
10758        return {
10759            'meta': self.meta,
10760            'rate_limit': self.rate_limit,
10761            'resource': self.resource,
10762        }
10763
10764    @classmethod
10765    def from_dict(cls, d):
10766        return cls(
10767            meta=d.get('meta'),
10768            rate_limit=d.get('rate_limit'),
10769            resource=d.get('resource'),
10770        )

ResourceCreateResponse reports how the Resources were created in the system.

ResourceCreateResponse(meta=None, rate_limit=None, resource=None)
10731    def __init__(
10732        self,
10733        meta=None,
10734        rate_limit=None,
10735        resource=None,
10736    ):
10737        self.meta = meta if meta is not None else None
10738        '''
10739         Reserved for future use.
10740        '''
10741        self.rate_limit = rate_limit if rate_limit is not None else None
10742        '''
10743         Rate limit information.
10744        '''
10745        self.resource = resource if resource is not None else None
10746        '''
10747         The created Resource.
10748        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

resource

The created Resource.

def to_dict(self)
10757    def to_dict(self):
10758        return {
10759            'meta': self.meta,
10760            'rate_limit': self.rate_limit,
10761            'resource': self.resource,
10762        }
@classmethod
def from_dict(cls, d)
10764    @classmethod
10765    def from_dict(cls, d):
10766        return cls(
10767            meta=d.get('meta'),
10768            rate_limit=d.get('rate_limit'),
10769            resource=d.get('resource'),
10770        )
class ResourceDeleteResponse:
10773class ResourceDeleteResponse:
10774    '''
10775     ResourceDeleteResponse returns information about a Resource that was deleted.
10776    '''
10777    __slots__ = [
10778        'meta',
10779        'rate_limit',
10780    ]
10781
10782    def __init__(
10783        self,
10784        meta=None,
10785        rate_limit=None,
10786    ):
10787        self.meta = meta if meta is not None else None
10788        '''
10789         Reserved for future use.
10790        '''
10791        self.rate_limit = rate_limit if rate_limit is not None else None
10792        '''
10793         Rate limit information.
10794        '''
10795
10796    def __repr__(self):
10797        return '<sdm.ResourceDeleteResponse ' + \
10798            'meta: ' + repr(self.meta) + ' ' +\
10799            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10800            '>'
10801
10802    def to_dict(self):
10803        return {
10804            'meta': self.meta,
10805            'rate_limit': self.rate_limit,
10806        }
10807
10808    @classmethod
10809    def from_dict(cls, d):
10810        return cls(
10811            meta=d.get('meta'),
10812            rate_limit=d.get('rate_limit'),
10813        )

ResourceDeleteResponse returns information about a Resource that was deleted.

ResourceDeleteResponse(meta=None, rate_limit=None)
10782    def __init__(
10783        self,
10784        meta=None,
10785        rate_limit=None,
10786    ):
10787        self.meta = meta if meta is not None else None
10788        '''
10789         Reserved for future use.
10790        '''
10791        self.rate_limit = rate_limit if rate_limit is not None else None
10792        '''
10793         Rate limit information.
10794        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
10802    def to_dict(self):
10803        return {
10804            'meta': self.meta,
10805            'rate_limit': self.rate_limit,
10806        }
@classmethod
def from_dict(cls, d)
10808    @classmethod
10809    def from_dict(cls, d):
10810        return cls(
10811            meta=d.get('meta'),
10812            rate_limit=d.get('rate_limit'),
10813        )
class ResourceGetResponse:
10816class ResourceGetResponse:
10817    '''
10818     ResourceGetResponse returns a requested Resource.
10819    '''
10820    __slots__ = [
10821        'meta',
10822        'rate_limit',
10823        'resource',
10824    ]
10825
10826    def __init__(
10827        self,
10828        meta=None,
10829        rate_limit=None,
10830        resource=None,
10831    ):
10832        self.meta = meta if meta is not None else None
10833        '''
10834         Reserved for future use.
10835        '''
10836        self.rate_limit = rate_limit if rate_limit is not None else None
10837        '''
10838         Rate limit information.
10839        '''
10840        self.resource = resource if resource is not None else None
10841        '''
10842         The requested Resource.
10843        '''
10844
10845    def __repr__(self):
10846        return '<sdm.ResourceGetResponse ' + \
10847            'meta: ' + repr(self.meta) + ' ' +\
10848            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10849            'resource: ' + repr(self.resource) + ' ' +\
10850            '>'
10851
10852    def to_dict(self):
10853        return {
10854            'meta': self.meta,
10855            'rate_limit': self.rate_limit,
10856            'resource': self.resource,
10857        }
10858
10859    @classmethod
10860    def from_dict(cls, d):
10861        return cls(
10862            meta=d.get('meta'),
10863            rate_limit=d.get('rate_limit'),
10864            resource=d.get('resource'),
10865        )

ResourceGetResponse returns a requested Resource.

ResourceGetResponse(meta=None, rate_limit=None, resource=None)
10826    def __init__(
10827        self,
10828        meta=None,
10829        rate_limit=None,
10830        resource=None,
10831    ):
10832        self.meta = meta if meta is not None else None
10833        '''
10834         Reserved for future use.
10835        '''
10836        self.rate_limit = rate_limit if rate_limit is not None else None
10837        '''
10838         Rate limit information.
10839        '''
10840        self.resource = resource if resource is not None else None
10841        '''
10842         The requested Resource.
10843        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

resource

The requested Resource.

def to_dict(self)
10852    def to_dict(self):
10853        return {
10854            'meta': self.meta,
10855            'rate_limit': self.rate_limit,
10856            'resource': self.resource,
10857        }
@classmethod
def from_dict(cls, d)
10859    @classmethod
10860    def from_dict(cls, d):
10861        return cls(
10862            meta=d.get('meta'),
10863            rate_limit=d.get('rate_limit'),
10864            resource=d.get('resource'),
10865        )
class ResourceUpdateResponse:
10868class ResourceUpdateResponse:
10869    '''
10870     ResourceUpdateResponse returns the fields of a Resource after it has been updated by
10871     a ResourceUpdateRequest.
10872    '''
10873    __slots__ = [
10874        'meta',
10875        'rate_limit',
10876        'resource',
10877    ]
10878
10879    def __init__(
10880        self,
10881        meta=None,
10882        rate_limit=None,
10883        resource=None,
10884    ):
10885        self.meta = meta if meta is not None else None
10886        '''
10887         Reserved for future use.
10888        '''
10889        self.rate_limit = rate_limit if rate_limit is not None else None
10890        '''
10891         Rate limit information.
10892        '''
10893        self.resource = resource if resource is not None else None
10894        '''
10895         The updated Resource.
10896        '''
10897
10898    def __repr__(self):
10899        return '<sdm.ResourceUpdateResponse ' + \
10900            'meta: ' + repr(self.meta) + ' ' +\
10901            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
10902            'resource: ' + repr(self.resource) + ' ' +\
10903            '>'
10904
10905    def to_dict(self):
10906        return {
10907            'meta': self.meta,
10908            'rate_limit': self.rate_limit,
10909            'resource': self.resource,
10910        }
10911
10912    @classmethod
10913    def from_dict(cls, d):
10914        return cls(
10915            meta=d.get('meta'),
10916            rate_limit=d.get('rate_limit'),
10917            resource=d.get('resource'),
10918        )

ResourceUpdateResponse returns the fields of a Resource after it has been updated by a ResourceUpdateRequest.

ResourceUpdateResponse(meta=None, rate_limit=None, resource=None)
10879    def __init__(
10880        self,
10881        meta=None,
10882        rate_limit=None,
10883        resource=None,
10884    ):
10885        self.meta = meta if meta is not None else None
10886        '''
10887         Reserved for future use.
10888        '''
10889        self.rate_limit = rate_limit if rate_limit is not None else None
10890        '''
10891         Rate limit information.
10892        '''
10893        self.resource = resource if resource is not None else None
10894        '''
10895         The updated Resource.
10896        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

resource

The updated Resource.

def to_dict(self)
10905    def to_dict(self):
10906        return {
10907            'meta': self.meta,
10908            'rate_limit': self.rate_limit,
10909            'resource': self.resource,
10910        }
@classmethod
def from_dict(cls, d)
10912    @classmethod
10913    def from_dict(cls, d):
10914        return cls(
10915            meta=d.get('meta'),
10916            rate_limit=d.get('rate_limit'),
10917            resource=d.get('resource'),
10918        )
class Role:
10921class Role:
10922    '''
10923     A Role has a list of access rules which determine which Resources the members
10924     of the Role have access to. An Account can be a member of multiple Roles via
10925     AccountAttachments.
10926    '''
10927    __slots__ = [
10928        'access_rules',
10929        'composite',
10930        'id',
10931        'name',
10932        'tags',
10933    ]
10934
10935    def __init__(
10936        self,
10937        access_rules=None,
10938        composite=None,
10939        id=None,
10940        name=None,
10941        tags=None,
10942    ):
10943        self.access_rules = access_rules if access_rules is not None else _porcelain_zero_value_access_rules(
10944        )
10945        '''
10946         AccessRules is a list of access rules defining the resources this Role has access to.
10947        '''
10948        self.composite = composite if composite is not None else False
10949        '''
10950         Composite is true if the Role is a composite role.
10951         
10952         Deprecated: composite roles are deprecated, use multi-role via
10953         AccountAttachments instead.
10954        '''
10955        self.id = id if id is not None else ''
10956        '''
10957         Unique identifier of the Role.
10958        '''
10959        self.name = name if name is not None else ''
10960        '''
10961         Unique human-readable name of the Role.
10962        '''
10963        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10964        '''
10965         Tags is a map of key, value pairs.
10966        '''
10967
10968    def __repr__(self):
10969        return '<sdm.Role ' + \
10970            'access_rules: ' + repr(self.access_rules) + ' ' +\
10971            'composite: ' + repr(self.composite) + ' ' +\
10972            'id: ' + repr(self.id) + ' ' +\
10973            'name: ' + repr(self.name) + ' ' +\
10974            'tags: ' + repr(self.tags) + ' ' +\
10975            '>'
10976
10977    def to_dict(self):
10978        return {
10979            'access_rules': self.access_rules,
10980            'composite': self.composite,
10981            'id': self.id,
10982            'name': self.name,
10983            'tags': self.tags,
10984        }
10985
10986    @classmethod
10987    def from_dict(cls, d):
10988        return cls(
10989            access_rules=d.get('access_rules'),
10990            composite=d.get('composite'),
10991            id=d.get('id'),
10992            name=d.get('name'),
10993            tags=d.get('tags'),
10994        )

A Role has a list of access rules which determine which Resources the members of the Role have access to. An Account can be a member of multiple Roles via AccountAttachments.

Role(access_rules=None, composite=None, id=None, name=None, tags=None)
10935    def __init__(
10936        self,
10937        access_rules=None,
10938        composite=None,
10939        id=None,
10940        name=None,
10941        tags=None,
10942    ):
10943        self.access_rules = access_rules if access_rules is not None else _porcelain_zero_value_access_rules(
10944        )
10945        '''
10946         AccessRules is a list of access rules defining the resources this Role has access to.
10947        '''
10948        self.composite = composite if composite is not None else False
10949        '''
10950         Composite is true if the Role is a composite role.
10951         
10952         Deprecated: composite roles are deprecated, use multi-role via
10953         AccountAttachments instead.
10954        '''
10955        self.id = id if id is not None else ''
10956        '''
10957         Unique identifier of the Role.
10958        '''
10959        self.name = name if name is not None else ''
10960        '''
10961         Unique human-readable name of the Role.
10962        '''
10963        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
10964        '''
10965         Tags is a map of key, value pairs.
10966        '''
access_rules

AccessRules is a list of access rules defining the resources this Role has access to.

composite

Composite is true if the Role is a composite role.

Deprecated: composite roles are deprecated, use multi-role via AccountAttachments instead.

id

Unique identifier of the Role.

name

Unique human-readable name of the Role.

tags

Tags is a map of key, value pairs.

def to_dict(self)
10977    def to_dict(self):
10978        return {
10979            'access_rules': self.access_rules,
10980            'composite': self.composite,
10981            'id': self.id,
10982            'name': self.name,
10983            'tags': self.tags,
10984        }
@classmethod
def from_dict(cls, d)
10986    @classmethod
10987    def from_dict(cls, d):
10988        return cls(
10989            access_rules=d.get('access_rules'),
10990            composite=d.get('composite'),
10991            id=d.get('id'),
10992            name=d.get('name'),
10993            tags=d.get('tags'),
10994        )
class RoleAttachment:
10997class RoleAttachment:
10998    '''
10999     A RoleAttachment assigns a role to a composite role.
11000     
11001     Deprecated: use multi-role via AccountAttachments instead.
11002    '''
11003    __slots__ = [
11004        'attached_role_id',
11005        'composite_role_id',
11006        'id',
11007    ]
11008
11009    def __init__(
11010        self,
11011        attached_role_id=None,
11012        composite_role_id=None,
11013        id=None,
11014    ):
11015        self.attached_role_id = attached_role_id if attached_role_id is not None else ''
11016        '''
11017         The id of the attached role of this RoleAttachment.
11018        '''
11019        self.composite_role_id = composite_role_id if composite_role_id is not None else ''
11020        '''
11021         The id of the composite role of this RoleAttachment.
11022        '''
11023        self.id = id if id is not None else ''
11024        '''
11025         Unique identifier of the RoleAttachment.
11026        '''
11027
11028    def __repr__(self):
11029        return '<sdm.RoleAttachment ' + \
11030            'attached_role_id: ' + repr(self.attached_role_id) + ' ' +\
11031            'composite_role_id: ' + repr(self.composite_role_id) + ' ' +\
11032            'id: ' + repr(self.id) + ' ' +\
11033            '>'
11034
11035    def to_dict(self):
11036        return {
11037            'attached_role_id': self.attached_role_id,
11038            'composite_role_id': self.composite_role_id,
11039            'id': self.id,
11040        }
11041
11042    @classmethod
11043    def from_dict(cls, d):
11044        return cls(
11045            attached_role_id=d.get('attached_role_id'),
11046            composite_role_id=d.get('composite_role_id'),
11047            id=d.get('id'),
11048        )

A RoleAttachment assigns a role to a composite role.

Deprecated: use multi-role via AccountAttachments instead.

RoleAttachment(attached_role_id=None, composite_role_id=None, id=None)
11009    def __init__(
11010        self,
11011        attached_role_id=None,
11012        composite_role_id=None,
11013        id=None,
11014    ):
11015        self.attached_role_id = attached_role_id if attached_role_id is not None else ''
11016        '''
11017         The id of the attached role of this RoleAttachment.
11018        '''
11019        self.composite_role_id = composite_role_id if composite_role_id is not None else ''
11020        '''
11021         The id of the composite role of this RoleAttachment.
11022        '''
11023        self.id = id if id is not None else ''
11024        '''
11025         Unique identifier of the RoleAttachment.
11026        '''
attached_role_id

The id of the attached role of this RoleAttachment.

composite_role_id

The id of the composite role of this RoleAttachment.

id

Unique identifier of the RoleAttachment.

def to_dict(self)
11035    def to_dict(self):
11036        return {
11037            'attached_role_id': self.attached_role_id,
11038            'composite_role_id': self.composite_role_id,
11039            'id': self.id,
11040        }
@classmethod
def from_dict(cls, d)
11042    @classmethod
11043    def from_dict(cls, d):
11044        return cls(
11045            attached_role_id=d.get('attached_role_id'),
11046            composite_role_id=d.get('composite_role_id'),
11047            id=d.get('id'),
11048        )
class RoleAttachmentCreateResponse:
11051class RoleAttachmentCreateResponse:
11052    '''
11053     RoleAttachmentCreateResponse reports how the RoleAttachments were created in the system.
11054     
11055     Deprecated: use multi-role via AccountAttachments instead.
11056    '''
11057    __slots__ = [
11058        'meta',
11059        'rate_limit',
11060        'role_attachment',
11061    ]
11062
11063    def __init__(
11064        self,
11065        meta=None,
11066        rate_limit=None,
11067        role_attachment=None,
11068    ):
11069        self.meta = meta if meta is not None else None
11070        '''
11071         Reserved for future use.
11072        '''
11073        self.rate_limit = rate_limit if rate_limit is not None else None
11074        '''
11075         Rate limit information.
11076        '''
11077        self.role_attachment = role_attachment if role_attachment is not None else None
11078        '''
11079         The created RoleAttachment.
11080        '''
11081
11082    def __repr__(self):
11083        return '<sdm.RoleAttachmentCreateResponse ' + \
11084            'meta: ' + repr(self.meta) + ' ' +\
11085            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
11086            'role_attachment: ' + repr(self.role_attachment) + ' ' +\
11087            '>'
11088
11089    def to_dict(self):
11090        return {
11091            'meta': self.meta,
11092            'rate_limit': self.rate_limit,
11093            'role_attachment': self.role_attachment,
11094        }
11095
11096    @classmethod
11097    def from_dict(cls, d):
11098        return cls(
11099            meta=d.get('meta'),
11100            rate_limit=d.get('rate_limit'),
11101            role_attachment=d.get('role_attachment'),
11102        )

RoleAttachmentCreateResponse reports how the RoleAttachments were created in the system.

Deprecated: use multi-role via AccountAttachments instead.

RoleAttachmentCreateResponse(meta=None, rate_limit=None, role_attachment=None)
11063    def __init__(
11064        self,
11065        meta=None,
11066        rate_limit=None,
11067        role_attachment=None,
11068    ):
11069        self.meta = meta if meta is not None else None
11070        '''
11071         Reserved for future use.
11072        '''
11073        self.rate_limit = rate_limit if rate_limit is not None else None
11074        '''
11075         Rate limit information.
11076        '''
11077        self.role_attachment = role_attachment if role_attachment is not None else None
11078        '''
11079         The created RoleAttachment.
11080        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

role_attachment

The created RoleAttachment.

def to_dict(self)
11089    def to_dict(self):
11090        return {
11091            'meta': self.meta,
11092            'rate_limit': self.rate_limit,
11093            'role_attachment': self.role_attachment,
11094        }
@classmethod
def from_dict(cls, d)
11096    @classmethod
11097    def from_dict(cls, d):
11098        return cls(
11099            meta=d.get('meta'),
11100            rate_limit=d.get('rate_limit'),
11101            role_attachment=d.get('role_attachment'),
11102        )
class RoleAttachmentDeleteResponse:
11105class RoleAttachmentDeleteResponse:
11106    '''
11107     RoleAttachmentDeleteResponse returns information about a RoleAttachment that was deleted.
11108     
11109     Deprecated: use multi-role via AccountAttachments instead.
11110    '''
11111    __slots__ = [
11112        'meta',
11113        'rate_limit',
11114    ]
11115
11116    def __init__(
11117        self,
11118        meta=None,
11119        rate_limit=None,
11120    ):
11121        self.meta = meta if meta is not None else None
11122        '''
11123         Reserved for future use.
11124        '''
11125        self.rate_limit = rate_limit if rate_limit is not None else None
11126        '''
11127         Rate limit information.
11128        '''
11129
11130    def __repr__(self):
11131        return '<sdm.RoleAttachmentDeleteResponse ' + \
11132            'meta: ' + repr(self.meta) + ' ' +\
11133            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
11134            '>'
11135
11136    def to_dict(self):
11137        return {
11138            'meta': self.meta,
11139            'rate_limit': self.rate_limit,
11140        }
11141
11142    @classmethod
11143    def from_dict(cls, d):
11144        return cls(
11145            meta=d.get('meta'),
11146            rate_limit=d.get('rate_limit'),
11147        )

RoleAttachmentDeleteResponse returns information about a RoleAttachment that was deleted.

Deprecated: use multi-role via AccountAttachments instead.

RoleAttachmentDeleteResponse(meta=None, rate_limit=None)
11116    def __init__(
11117        self,
11118        meta=None,
11119        rate_limit=None,
11120    ):
11121        self.meta = meta if meta is not None else None
11122        '''
11123         Reserved for future use.
11124        '''
11125        self.rate_limit = rate_limit if rate_limit is not None else None
11126        '''
11127         Rate limit information.
11128        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
11136    def to_dict(self):
11137        return {
11138            'meta': self.meta,
11139            'rate_limit': self.rate_limit,
11140        }
@classmethod
def from_dict(cls, d)
11142    @classmethod
11143    def from_dict(cls, d):
11144        return cls(
11145            meta=d.get('meta'),
11146            rate_limit=d.get('rate_limit'),
11147        )
class RoleAttachmentGetResponse:
11150class RoleAttachmentGetResponse:
11151    '''
11152     RoleAttachmentGetResponse returns a requested RoleAttachment.
11153     
11154     Deprecated: use multi-role via AccountAttachments instead.
11155    '''
11156    __slots__ = [
11157        'meta',
11158        'rate_limit',
11159        'role_attachment',
11160    ]
11161
11162    def __init__(
11163        self,
11164        meta=None,
11165        rate_limit=None,
11166        role_attachment=None,
11167    ):
11168        self.meta = meta if meta is not None else None
11169        '''
11170         Reserved for future use.
11171        '''
11172        self.rate_limit = rate_limit if rate_limit is not None else None
11173        '''
11174         Rate limit information.
11175        '''
11176        self.role_attachment = role_attachment if role_attachment is not None else None
11177        '''
11178         The requested RoleAttachment.
11179        '''
11180
11181    def __repr__(self):
11182        return '<sdm.RoleAttachmentGetResponse ' + \
11183            'meta: ' + repr(self.meta) + ' ' +\
11184            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
11185            'role_attachment: ' + repr(self.role_attachment) + ' ' +\
11186            '>'
11187
11188    def to_dict(self):
11189        return {
11190            'meta': self.meta,
11191            'rate_limit': self.rate_limit,
11192            'role_attachment': self.role_attachment,
11193        }
11194
11195    @classmethod
11196    def from_dict(cls, d):
11197        return cls(
11198            meta=d.get('meta'),
11199            rate_limit=d.get('rate_limit'),
11200            role_attachment=d.get('role_attachment'),
11201        )

RoleAttachmentGetResponse returns a requested RoleAttachment.

Deprecated: use multi-role via AccountAttachments instead.

RoleAttachmentGetResponse(meta=None, rate_limit=None, role_attachment=None)
11162    def __init__(
11163        self,
11164        meta=None,
11165        rate_limit=None,
11166        role_attachment=None,
11167    ):
11168        self.meta = meta if meta is not None else None
11169        '''
11170         Reserved for future use.
11171        '''
11172        self.rate_limit = rate_limit if rate_limit is not None else None
11173        '''
11174         Rate limit information.
11175        '''
11176        self.role_attachment = role_attachment if role_attachment is not None else None
11177        '''
11178         The requested RoleAttachment.
11179        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

role_attachment

The requested RoleAttachment.

def to_dict(self)
11188    def to_dict(self):
11189        return {
11190            'meta': self.meta,
11191            'rate_limit': self.rate_limit,
11192            'role_attachment': self.role_attachment,
11193        }
@classmethod
def from_dict(cls, d)
11195    @classmethod
11196    def from_dict(cls, d):
11197        return cls(
11198            meta=d.get('meta'),
11199            rate_limit=d.get('rate_limit'),
11200            role_attachment=d.get('role_attachment'),
11201        )
class RoleCreateResponse:
11204class RoleCreateResponse:
11205    '''
11206     RoleCreateResponse reports how the Roles were created in the system. It can
11207     communicate partial successes or failures.
11208    '''
11209    __slots__ = [
11210        'meta',
11211        'rate_limit',
11212        'role',
11213    ]
11214
11215    def __init__(
11216        self,
11217        meta=None,
11218        rate_limit=None,
11219        role=None,
11220    ):
11221        self.meta = meta if meta is not None else None
11222        '''
11223         Reserved for future use.
11224        '''
11225        self.rate_limit = rate_limit if rate_limit is not None else None
11226        '''
11227         Rate limit information.
11228        '''
11229        self.role = role if role is not None else None
11230        '''
11231         The created Role.
11232        '''
11233
11234    def __repr__(self):
11235        return '<sdm.RoleCreateResponse ' + \
11236            'meta: ' + repr(self.meta) + ' ' +\
11237            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
11238            'role: ' + repr(self.role) + ' ' +\
11239            '>'
11240
11241    def to_dict(self):
11242        return {
11243            'meta': self.meta,
11244            'rate_limit': self.rate_limit,
11245            'role': self.role,
11246        }
11247
11248    @classmethod
11249    def from_dict(cls, d):
11250        return cls(
11251            meta=d.get('meta'),
11252            rate_limit=d.get('rate_limit'),
11253            role=d.get('role'),
11254        )

RoleCreateResponse reports how the Roles were created in the system. It can communicate partial successes or failures.

RoleCreateResponse(meta=None, rate_limit=None, role=None)
11215    def __init__(
11216        self,
11217        meta=None,
11218        rate_limit=None,
11219        role=None,
11220    ):
11221        self.meta = meta if meta is not None else None
11222        '''
11223         Reserved for future use.
11224        '''
11225        self.rate_limit = rate_limit if rate_limit is not None else None
11226        '''
11227         Rate limit information.
11228        '''
11229        self.role = role if role is not None else None
11230        '''
11231         The created Role.
11232        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

role

The created Role.

def to_dict(self)
11241    def to_dict(self):
11242        return {
11243            'meta': self.meta,
11244            'rate_limit': self.rate_limit,
11245            'role': self.role,
11246        }
@classmethod
def from_dict(cls, d)
11248    @classmethod
11249    def from_dict(cls, d):
11250        return cls(
11251            meta=d.get('meta'),
11252            rate_limit=d.get('rate_limit'),
11253            role=d.get('role'),
11254        )
class RoleDeleteResponse:
11257class RoleDeleteResponse:
11258    '''
11259     RoleDeleteResponse returns information about a Role that was deleted.
11260    '''
11261    __slots__ = [
11262        'meta',
11263        'rate_limit',
11264    ]
11265
11266    def __init__(
11267        self,
11268        meta=None,
11269        rate_limit=None,
11270    ):
11271        self.meta = meta if meta is not None else None
11272        '''
11273         Reserved for future use.
11274        '''
11275        self.rate_limit = rate_limit if rate_limit is not None else None
11276        '''
11277         Rate limit information.
11278        '''
11279
11280    def __repr__(self):
11281        return '<sdm.RoleDeleteResponse ' + \
11282            'meta: ' + repr(self.meta) + ' ' +\
11283            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
11284            '>'
11285
11286    def to_dict(self):
11287        return {
11288            'meta': self.meta,
11289            'rate_limit': self.rate_limit,
11290        }
11291
11292    @classmethod
11293    def from_dict(cls, d):
11294        return cls(
11295            meta=d.get('meta'),
11296            rate_limit=d.get('rate_limit'),
11297        )

RoleDeleteResponse returns information about a Role that was deleted.

RoleDeleteResponse(meta=None, rate_limit=None)
11266    def __init__(
11267        self,
11268        meta=None,
11269        rate_limit=None,
11270    ):
11271        self.meta = meta if meta is not None else None
11272        '''
11273         Reserved for future use.
11274        '''
11275        self.rate_limit = rate_limit if rate_limit is not None else None
11276        '''
11277         Rate limit information.
11278        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
11286    def to_dict(self):
11287        return {
11288            'meta': self.meta,
11289            'rate_limit': self.rate_limit,
11290        }
@classmethod
def from_dict(cls, d)
11292    @classmethod
11293    def from_dict(cls, d):
11294        return cls(
11295            meta=d.get('meta'),
11296            rate_limit=d.get('rate_limit'),
11297        )
class RoleGetResponse:
11300class RoleGetResponse:
11301    '''
11302     RoleGetResponse returns a requested Role.
11303    '''
11304    __slots__ = [
11305        'meta',
11306        'rate_limit',
11307        'role',
11308    ]
11309
11310    def __init__(
11311        self,
11312        meta=None,
11313        rate_limit=None,
11314        role=None,
11315    ):
11316        self.meta = meta if meta is not None else None
11317        '''
11318         Reserved for future use.
11319        '''
11320        self.rate_limit = rate_limit if rate_limit is not None else None
11321        '''
11322         Rate limit information.
11323        '''
11324        self.role = role if role is not None else None
11325        '''
11326         The requested Role.
11327        '''
11328
11329    def __repr__(self):
11330        return '<sdm.RoleGetResponse ' + \
11331            'meta: ' + repr(self.meta) + ' ' +\
11332            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
11333            'role: ' + repr(self.role) + ' ' +\
11334            '>'
11335
11336    def to_dict(self):
11337        return {
11338            'meta': self.meta,
11339            'rate_limit': self.rate_limit,
11340            'role': self.role,
11341        }
11342
11343    @classmethod
11344    def from_dict(cls, d):
11345        return cls(
11346            meta=d.get('meta'),
11347            rate_limit=d.get('rate_limit'),
11348            role=d.get('role'),
11349        )

RoleGetResponse returns a requested Role.

RoleGetResponse(meta=None, rate_limit=None, role=None)
11310    def __init__(
11311        self,
11312        meta=None,
11313        rate_limit=None,
11314        role=None,
11315    ):
11316        self.meta = meta if meta is not None else None
11317        '''
11318         Reserved for future use.
11319        '''
11320        self.rate_limit = rate_limit if rate_limit is not None else None
11321        '''
11322         Rate limit information.
11323        '''
11324        self.role = role if role is not None else None
11325        '''
11326         The requested Role.
11327        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

role

The requested Role.

def to_dict(self)
11336    def to_dict(self):
11337        return {
11338            'meta': self.meta,
11339            'rate_limit': self.rate_limit,
11340            'role': self.role,
11341        }
@classmethod
def from_dict(cls, d)
11343    @classmethod
11344    def from_dict(cls, d):
11345        return cls(
11346            meta=d.get('meta'),
11347            rate_limit=d.get('rate_limit'),
11348            role=d.get('role'),
11349        )
class RoleGrant:
11352class RoleGrant:
11353    '''
11354     A RoleGrant connects a resource to a role, granting members of the role access to that resource.
11355     
11356     Deprecated: use Role access rules instead.
11357    '''
11358    __slots__ = [
11359        'id',
11360        'resource_id',
11361        'role_id',
11362    ]
11363
11364    def __init__(
11365        self,
11366        id=None,
11367        resource_id=None,
11368        role_id=None,
11369    ):
11370        self.id = id if id is not None else ''
11371        '''
11372         Unique identifier of the RoleGrant.
11373        '''
11374        self.resource_id = resource_id if resource_id is not None else ''
11375        '''
11376         The id of the resource of this RoleGrant.
11377        '''
11378        self.role_id = role_id if role_id is not None else ''
11379        '''
11380         The id of the attached role of this RoleGrant.
11381        '''
11382
11383    def __repr__(self):
11384        return '<sdm.RoleGrant ' + \
11385            'id: ' + repr(self.id) + ' ' +\
11386            'resource_id: ' + repr(self.resource_id) + ' ' +\
11387            'role_id: ' + repr(self.role_id) + ' ' +\
11388            '>'
11389
11390    def to_dict(self):
11391        return {
11392            'id': self.id,
11393            'resource_id': self.resource_id,
11394            'role_id': self.role_id,
11395        }
11396
11397    @classmethod
11398    def from_dict(cls, d):
11399        return cls(
11400            id=d.get('id'),
11401            resource_id=d.get('resource_id'),
11402            role_id=d.get('role_id'),
11403        )

A RoleGrant connects a resource to a role, granting members of the role access to that resource.

Deprecated: use Role access rules instead.

RoleGrant(id=None, resource_id=None, role_id=None)
11364    def __init__(
11365        self,
11366        id=None,
11367        resource_id=None,
11368        role_id=None,
11369    ):
11370        self.id = id if id is not None else ''
11371        '''
11372         Unique identifier of the RoleGrant.
11373        '''
11374        self.resource_id = resource_id if resource_id is not None else ''
11375        '''
11376         The id of the resource of this RoleGrant.
11377        '''
11378        self.role_id = role_id if role_id is not None else ''
11379        '''
11380         The id of the attached role of this RoleGrant.
11381        '''
id

Unique identifier of the RoleGrant.

resource_id

The id of the resource of this RoleGrant.

role_id

The id of the attached role of this RoleGrant.

def to_dict(self)
11390    def to_dict(self):
11391        return {
11392            'id': self.id,
11393            'resource_id': self.resource_id,
11394            'role_id': self.role_id,
11395        }
@classmethod
def from_dict(cls, d)
11397    @classmethod
11398    def from_dict(cls, d):
11399        return cls(
11400            id=d.get('id'),
11401            resource_id=d.get('resource_id'),
11402            role_id=d.get('role_id'),
11403        )
class RoleGrantCreateResponse:
11406class RoleGrantCreateResponse:
11407    '''
11408     RoleGrantCreateResponse reports how the RoleGrants were created in the system.
11409     
11410     Deprecated: use Role access rules instead.
11411    '''
11412    __slots__ = [
11413        'meta',
11414        'rate_limit',
11415        'role_grant',
11416    ]
11417
11418    def __init__(
11419        self,
11420        meta=None,
11421        rate_limit=None,
11422        role_grant=None,
11423    ):
11424        self.meta = meta if meta is not None else None
11425        '''
11426         Reserved for future use.
11427        '''
11428        self.rate_limit = rate_limit if rate_limit is not None else None
11429        '''
11430         Rate limit information.
11431        '''
11432        self.role_grant = role_grant if role_grant is not None else None
11433        '''
11434         The created RoleGrant.
11435        '''
11436
11437    def __repr__(self):
11438        return '<sdm.RoleGrantCreateResponse ' + \
11439            'meta: ' + repr(self.meta) + ' ' +\
11440            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
11441            'role_grant: ' + repr(self.role_grant) + ' ' +\
11442            '>'
11443
11444    def to_dict(self):
11445        return {
11446            'meta': self.meta,
11447            'rate_limit': self.rate_limit,
11448            'role_grant': self.role_grant,
11449        }
11450
11451    @classmethod
11452    def from_dict(cls, d):
11453        return cls(
11454            meta=d.get('meta'),
11455            rate_limit=d.get('rate_limit'),
11456            role_grant=d.get('role_grant'),
11457        )

RoleGrantCreateResponse reports how the RoleGrants were created in the system.

Deprecated: use Role access rules instead.

RoleGrantCreateResponse(meta=None, rate_limit=None, role_grant=None)
11418    def __init__(
11419        self,
11420        meta=None,
11421        rate_limit=None,
11422        role_grant=None,
11423    ):
11424        self.meta = meta if meta is not None else None
11425        '''
11426         Reserved for future use.
11427        '''
11428        self.rate_limit = rate_limit if rate_limit is not None else None
11429        '''
11430         Rate limit information.
11431        '''
11432        self.role_grant = role_grant if role_grant is not None else None
11433        '''
11434         The created RoleGrant.
11435        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

role_grant

The created RoleGrant.

def to_dict(self)
11444    def to_dict(self):
11445        return {
11446            'meta': self.meta,
11447            'rate_limit': self.rate_limit,
11448            'role_grant': self.role_grant,
11449        }
@classmethod
def from_dict(cls, d)
11451    @classmethod
11452    def from_dict(cls, d):
11453        return cls(
11454            meta=d.get('meta'),
11455            rate_limit=d.get('rate_limit'),
11456            role_grant=d.get('role_grant'),
11457        )
class RoleGrantDeleteResponse:
11460class RoleGrantDeleteResponse:
11461    '''
11462     RoleGrantDeleteResponse returns information about a RoleGrant that was deleted.
11463     
11464     Deprecated: use Role access rules instead.
11465    '''
11466    __slots__ = [
11467        'meta',
11468        'rate_limit',
11469    ]
11470
11471    def __init__(
11472        self,
11473        meta=None,
11474        rate_limit=None,
11475    ):
11476        self.meta = meta if meta is not None else None
11477        '''
11478         Reserved for future use.
11479        '''
11480        self.rate_limit = rate_limit if rate_limit is not None else None
11481        '''
11482         Rate limit information.
11483        '''
11484
11485    def __repr__(self):
11486        return '<sdm.RoleGrantDeleteResponse ' + \
11487            'meta: ' + repr(self.meta) + ' ' +\
11488            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
11489            '>'
11490
11491    def to_dict(self):
11492        return {
11493            'meta': self.meta,
11494            'rate_limit': self.rate_limit,
11495        }
11496
11497    @classmethod
11498    def from_dict(cls, d):
11499        return cls(
11500            meta=d.get('meta'),
11501            rate_limit=d.get('rate_limit'),
11502        )

RoleGrantDeleteResponse returns information about a RoleGrant that was deleted.

Deprecated: use Role access rules instead.

RoleGrantDeleteResponse(meta=None, rate_limit=None)
11471    def __init__(
11472        self,
11473        meta=None,
11474        rate_limit=None,
11475    ):
11476        self.meta = meta if meta is not None else None
11477        '''
11478         Reserved for future use.
11479        '''
11480        self.rate_limit = rate_limit if rate_limit is not None else None
11481        '''
11482         Rate limit information.
11483        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
11491    def to_dict(self):
11492        return {
11493            'meta': self.meta,
11494            'rate_limit': self.rate_limit,
11495        }
@classmethod
def from_dict(cls, d)
11497    @classmethod
11498    def from_dict(cls, d):
11499        return cls(
11500            meta=d.get('meta'),
11501            rate_limit=d.get('rate_limit'),
11502        )
class RoleGrantGetResponse:
11505class RoleGrantGetResponse:
11506    '''
11507     RoleGrantGetResponse returns a requested RoleGrant.
11508     
11509     Deprecated: use Role access rules instead.
11510    '''
11511    __slots__ = [
11512        'meta',
11513        'rate_limit',
11514        'role_grant',
11515    ]
11516
11517    def __init__(
11518        self,
11519        meta=None,
11520        rate_limit=None,
11521        role_grant=None,
11522    ):
11523        self.meta = meta if meta is not None else None
11524        '''
11525         Reserved for future use.
11526        '''
11527        self.rate_limit = rate_limit if rate_limit is not None else None
11528        '''
11529         Rate limit information.
11530        '''
11531        self.role_grant = role_grant if role_grant is not None else None
11532        '''
11533         The requested RoleGrant.
11534        '''
11535
11536    def __repr__(self):
11537        return '<sdm.RoleGrantGetResponse ' + \
11538            'meta: ' + repr(self.meta) + ' ' +\
11539            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
11540            'role_grant: ' + repr(self.role_grant) + ' ' +\
11541            '>'
11542
11543    def to_dict(self):
11544        return {
11545            'meta': self.meta,
11546            'rate_limit': self.rate_limit,
11547            'role_grant': self.role_grant,
11548        }
11549
11550    @classmethod
11551    def from_dict(cls, d):
11552        return cls(
11553            meta=d.get('meta'),
11554            rate_limit=d.get('rate_limit'),
11555            role_grant=d.get('role_grant'),
11556        )

RoleGrantGetResponse returns a requested RoleGrant.

Deprecated: use Role access rules instead.

RoleGrantGetResponse(meta=None, rate_limit=None, role_grant=None)
11517    def __init__(
11518        self,
11519        meta=None,
11520        rate_limit=None,
11521        role_grant=None,
11522    ):
11523        self.meta = meta if meta is not None else None
11524        '''
11525         Reserved for future use.
11526        '''
11527        self.rate_limit = rate_limit if rate_limit is not None else None
11528        '''
11529         Rate limit information.
11530        '''
11531        self.role_grant = role_grant if role_grant is not None else None
11532        '''
11533         The requested RoleGrant.
11534        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

role_grant

The requested RoleGrant.

def to_dict(self)
11543    def to_dict(self):
11544        return {
11545            'meta': self.meta,
11546            'rate_limit': self.rate_limit,
11547            'role_grant': self.role_grant,
11548        }
@classmethod
def from_dict(cls, d)
11550    @classmethod
11551    def from_dict(cls, d):
11552        return cls(
11553            meta=d.get('meta'),
11554            rate_limit=d.get('rate_limit'),
11555            role_grant=d.get('role_grant'),
11556        )
class RoleUpdateResponse:
11559class RoleUpdateResponse:
11560    '''
11561     RoleUpdateResponse returns the fields of a Role after it has been updated by
11562     a RoleUpdateRequest.
11563    '''
11564    __slots__ = [
11565        'meta',
11566        'rate_limit',
11567        'role',
11568    ]
11569
11570    def __init__(
11571        self,
11572        meta=None,
11573        rate_limit=None,
11574        role=None,
11575    ):
11576        self.meta = meta if meta is not None else None
11577        '''
11578         Reserved for future use.
11579        '''
11580        self.rate_limit = rate_limit if rate_limit is not None else None
11581        '''
11582         Rate limit information.
11583        '''
11584        self.role = role if role is not None else None
11585        '''
11586         The updated Role.
11587        '''
11588
11589    def __repr__(self):
11590        return '<sdm.RoleUpdateResponse ' + \
11591            'meta: ' + repr(self.meta) + ' ' +\
11592            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
11593            'role: ' + repr(self.role) + ' ' +\
11594            '>'
11595
11596    def to_dict(self):
11597        return {
11598            'meta': self.meta,
11599            'rate_limit': self.rate_limit,
11600            'role': self.role,
11601        }
11602
11603    @classmethod
11604    def from_dict(cls, d):
11605        return cls(
11606            meta=d.get('meta'),
11607            rate_limit=d.get('rate_limit'),
11608            role=d.get('role'),
11609        )

RoleUpdateResponse returns the fields of a Role after it has been updated by a RoleUpdateRequest.

RoleUpdateResponse(meta=None, rate_limit=None, role=None)
11570    def __init__(
11571        self,
11572        meta=None,
11573        rate_limit=None,
11574        role=None,
11575    ):
11576        self.meta = meta if meta is not None else None
11577        '''
11578         Reserved for future use.
11579        '''
11580        self.rate_limit = rate_limit if rate_limit is not None else None
11581        '''
11582         Rate limit information.
11583        '''
11584        self.role = role if role is not None else None
11585        '''
11586         The updated Role.
11587        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

role

The updated Role.

def to_dict(self)
11596    def to_dict(self):
11597        return {
11598            'meta': self.meta,
11599            'rate_limit': self.rate_limit,
11600            'role': self.role,
11601        }
@classmethod
def from_dict(cls, d)
11603    @classmethod
11604    def from_dict(cls, d):
11605        return cls(
11606            meta=d.get('meta'),
11607            rate_limit=d.get('rate_limit'),
11608            role=d.get('role'),
11609        )
class SQLServer:
11612class SQLServer:
11613    '''
11614
11615    '''
11616    __slots__ = [
11617        'bind_interface',
11618        'database',
11619        'egress_filter',
11620        'healthy',
11621        'hostname',
11622        'id',
11623        'name',
11624        'override_database',
11625        'password',
11626        'port',
11627        'port_override',
11628        'schema',
11629        'secret_store_id',
11630        'tags',
11631        'username',
11632    ]
11633
11634    def __init__(
11635        self,
11636        bind_interface=None,
11637        database=None,
11638        egress_filter=None,
11639        healthy=None,
11640        hostname=None,
11641        id=None,
11642        name=None,
11643        override_database=None,
11644        password=None,
11645        port=None,
11646        port_override=None,
11647        schema=None,
11648        secret_store_id=None,
11649        tags=None,
11650        username=None,
11651    ):
11652        self.bind_interface = bind_interface if bind_interface is not None else ''
11653        '''
11654         Bind interface
11655        '''
11656        self.database = database if database is not None else ''
11657        '''
11658
11659        '''
11660        self.egress_filter = egress_filter if egress_filter is not None else ''
11661        '''
11662         A filter applied to the routing logic to pin datasource to nodes.
11663        '''
11664        self.healthy = healthy if healthy is not None else False
11665        '''
11666         True if the datasource is reachable and the credentials are valid.
11667        '''
11668        self.hostname = hostname if hostname is not None else ''
11669        '''
11670
11671        '''
11672        self.id = id if id is not None else ''
11673        '''
11674         Unique identifier of the Resource.
11675        '''
11676        self.name = name if name is not None else ''
11677        '''
11678         Unique human-readable name of the Resource.
11679        '''
11680        self.override_database = override_database if override_database is not None else False
11681        '''
11682
11683        '''
11684        self.password = password if password is not None else ''
11685        '''
11686
11687        '''
11688        self.port = port if port is not None else 0
11689        '''
11690
11691        '''
11692        self.port_override = port_override if port_override is not None else 0
11693        '''
11694
11695        '''
11696        self.schema = schema if schema is not None else ''
11697        '''
11698
11699        '''
11700        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11701        '''
11702         ID of the secret store containing credentials for this resource, if any.
11703        '''
11704        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11705        '''
11706         Tags is a map of key, value pairs.
11707        '''
11708        self.username = username if username is not None else ''
11709        '''
11710
11711        '''
11712
11713    def __repr__(self):
11714        return '<sdm.SQLServer ' + \
11715            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
11716            'database: ' + repr(self.database) + ' ' +\
11717            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
11718            'healthy: ' + repr(self.healthy) + ' ' +\
11719            'hostname: ' + repr(self.hostname) + ' ' +\
11720            'id: ' + repr(self.id) + ' ' +\
11721            'name: ' + repr(self.name) + ' ' +\
11722            'override_database: ' + repr(self.override_database) + ' ' +\
11723            'password: ' + repr(self.password) + ' ' +\
11724            'port: ' + repr(self.port) + ' ' +\
11725            'port_override: ' + repr(self.port_override) + ' ' +\
11726            'schema: ' + repr(self.schema) + ' ' +\
11727            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
11728            'tags: ' + repr(self.tags) + ' ' +\
11729            'username: ' + repr(self.username) + ' ' +\
11730            '>'
11731
11732    def to_dict(self):
11733        return {
11734            'bind_interface': self.bind_interface,
11735            'database': self.database,
11736            'egress_filter': self.egress_filter,
11737            'healthy': self.healthy,
11738            'hostname': self.hostname,
11739            'id': self.id,
11740            'name': self.name,
11741            'override_database': self.override_database,
11742            'password': self.password,
11743            'port': self.port,
11744            'port_override': self.port_override,
11745            'schema': self.schema,
11746            'secret_store_id': self.secret_store_id,
11747            'tags': self.tags,
11748            'username': self.username,
11749        }
11750
11751    @classmethod
11752    def from_dict(cls, d):
11753        return cls(
11754            bind_interface=d.get('bind_interface'),
11755            database=d.get('database'),
11756            egress_filter=d.get('egress_filter'),
11757            healthy=d.get('healthy'),
11758            hostname=d.get('hostname'),
11759            id=d.get('id'),
11760            name=d.get('name'),
11761            override_database=d.get('override_database'),
11762            password=d.get('password'),
11763            port=d.get('port'),
11764            port_override=d.get('port_override'),
11765            schema=d.get('schema'),
11766            secret_store_id=d.get('secret_store_id'),
11767            tags=d.get('tags'),
11768            username=d.get('username'),
11769        )
SQLServer( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, override_database=None, password=None, port=None, port_override=None, schema=None, secret_store_id=None, tags=None, username=None)
11634    def __init__(
11635        self,
11636        bind_interface=None,
11637        database=None,
11638        egress_filter=None,
11639        healthy=None,
11640        hostname=None,
11641        id=None,
11642        name=None,
11643        override_database=None,
11644        password=None,
11645        port=None,
11646        port_override=None,
11647        schema=None,
11648        secret_store_id=None,
11649        tags=None,
11650        username=None,
11651    ):
11652        self.bind_interface = bind_interface if bind_interface is not None else ''
11653        '''
11654         Bind interface
11655        '''
11656        self.database = database if database is not None else ''
11657        '''
11658
11659        '''
11660        self.egress_filter = egress_filter if egress_filter is not None else ''
11661        '''
11662         A filter applied to the routing logic to pin datasource to nodes.
11663        '''
11664        self.healthy = healthy if healthy is not None else False
11665        '''
11666         True if the datasource is reachable and the credentials are valid.
11667        '''
11668        self.hostname = hostname if hostname is not None else ''
11669        '''
11670
11671        '''
11672        self.id = id if id is not None else ''
11673        '''
11674         Unique identifier of the Resource.
11675        '''
11676        self.name = name if name is not None else ''
11677        '''
11678         Unique human-readable name of the Resource.
11679        '''
11680        self.override_database = override_database if override_database is not None else False
11681        '''
11682
11683        '''
11684        self.password = password if password is not None else ''
11685        '''
11686
11687        '''
11688        self.port = port if port is not None else 0
11689        '''
11690
11691        '''
11692        self.port_override = port_override if port_override is not None else 0
11693        '''
11694
11695        '''
11696        self.schema = schema if schema is not None else ''
11697        '''
11698
11699        '''
11700        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11701        '''
11702         ID of the secret store containing credentials for this resource, if any.
11703        '''
11704        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11705        '''
11706         Tags is a map of key, value pairs.
11707        '''
11708        self.username = username if username is not None else ''
11709        '''
11710
11711        '''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

override_database
password
port
port_override
schema
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
11732    def to_dict(self):
11733        return {
11734            'bind_interface': self.bind_interface,
11735            'database': self.database,
11736            'egress_filter': self.egress_filter,
11737            'healthy': self.healthy,
11738            'hostname': self.hostname,
11739            'id': self.id,
11740            'name': self.name,
11741            'override_database': self.override_database,
11742            'password': self.password,
11743            'port': self.port,
11744            'port_override': self.port_override,
11745            'schema': self.schema,
11746            'secret_store_id': self.secret_store_id,
11747            'tags': self.tags,
11748            'username': self.username,
11749        }
@classmethod
def from_dict(cls, d)
11751    @classmethod
11752    def from_dict(cls, d):
11753        return cls(
11754            bind_interface=d.get('bind_interface'),
11755            database=d.get('database'),
11756            egress_filter=d.get('egress_filter'),
11757            healthy=d.get('healthy'),
11758            hostname=d.get('hostname'),
11759            id=d.get('id'),
11760            name=d.get('name'),
11761            override_database=d.get('override_database'),
11762            password=d.get('password'),
11763            port=d.get('port'),
11764            port_override=d.get('port_override'),
11765            schema=d.get('schema'),
11766            secret_store_id=d.get('secret_store_id'),
11767            tags=d.get('tags'),
11768            username=d.get('username'),
11769        )
class SSH:
11772class SSH:
11773    '''
11774
11775    '''
11776    __slots__ = [
11777        'allow_deprecated_key_exchanges',
11778        'bind_interface',
11779        'egress_filter',
11780        'healthy',
11781        'hostname',
11782        'id',
11783        'name',
11784        'port',
11785        'port_forwarding',
11786        'port_override',
11787        'public_key',
11788        'secret_store_id',
11789        'tags',
11790        'username',
11791    ]
11792
11793    def __init__(
11794        self,
11795        allow_deprecated_key_exchanges=None,
11796        bind_interface=None,
11797        egress_filter=None,
11798        healthy=None,
11799        hostname=None,
11800        id=None,
11801        name=None,
11802        port=None,
11803        port_forwarding=None,
11804        port_override=None,
11805        public_key=None,
11806        secret_store_id=None,
11807        tags=None,
11808        username=None,
11809    ):
11810        self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges if allow_deprecated_key_exchanges is not None else False
11811        '''
11812
11813        '''
11814        self.bind_interface = bind_interface if bind_interface is not None else ''
11815        '''
11816         Bind interface
11817        '''
11818        self.egress_filter = egress_filter if egress_filter is not None else ''
11819        '''
11820         A filter applied to the routing logic to pin datasource to nodes.
11821        '''
11822        self.healthy = healthy if healthy is not None else False
11823        '''
11824         True if the datasource is reachable and the credentials are valid.
11825        '''
11826        self.hostname = hostname if hostname is not None else ''
11827        '''
11828
11829        '''
11830        self.id = id if id is not None else ''
11831        '''
11832         Unique identifier of the Resource.
11833        '''
11834        self.name = name if name is not None else ''
11835        '''
11836         Unique human-readable name of the Resource.
11837        '''
11838        self.port = port if port is not None else 0
11839        '''
11840
11841        '''
11842        self.port_forwarding = port_forwarding if port_forwarding is not None else False
11843        '''
11844
11845        '''
11846        self.port_override = port_override if port_override is not None else 0
11847        '''
11848
11849        '''
11850        self.public_key = public_key if public_key is not None else ''
11851        '''
11852
11853        '''
11854        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11855        '''
11856         ID of the secret store containing credentials for this resource, if any.
11857        '''
11858        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11859        '''
11860         Tags is a map of key, value pairs.
11861        '''
11862        self.username = username if username is not None else ''
11863        '''
11864
11865        '''
11866
11867    def __repr__(self):
11868        return '<sdm.SSH ' + \
11869            'allow_deprecated_key_exchanges: ' + repr(self.allow_deprecated_key_exchanges) + ' ' +\
11870            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
11871            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
11872            'healthy: ' + repr(self.healthy) + ' ' +\
11873            'hostname: ' + repr(self.hostname) + ' ' +\
11874            'id: ' + repr(self.id) + ' ' +\
11875            'name: ' + repr(self.name) + ' ' +\
11876            'port: ' + repr(self.port) + ' ' +\
11877            'port_forwarding: ' + repr(self.port_forwarding) + ' ' +\
11878            'port_override: ' + repr(self.port_override) + ' ' +\
11879            'public_key: ' + repr(self.public_key) + ' ' +\
11880            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
11881            'tags: ' + repr(self.tags) + ' ' +\
11882            'username: ' + repr(self.username) + ' ' +\
11883            '>'
11884
11885    def to_dict(self):
11886        return {
11887            'allow_deprecated_key_exchanges':
11888            self.allow_deprecated_key_exchanges,
11889            'bind_interface': self.bind_interface,
11890            'egress_filter': self.egress_filter,
11891            'healthy': self.healthy,
11892            'hostname': self.hostname,
11893            'id': self.id,
11894            'name': self.name,
11895            'port': self.port,
11896            'port_forwarding': self.port_forwarding,
11897            'port_override': self.port_override,
11898            'public_key': self.public_key,
11899            'secret_store_id': self.secret_store_id,
11900            'tags': self.tags,
11901            'username': self.username,
11902        }
11903
11904    @classmethod
11905    def from_dict(cls, d):
11906        return cls(
11907            allow_deprecated_key_exchanges=d.get(
11908                'allow_deprecated_key_exchanges'),
11909            bind_interface=d.get('bind_interface'),
11910            egress_filter=d.get('egress_filter'),
11911            healthy=d.get('healthy'),
11912            hostname=d.get('hostname'),
11913            id=d.get('id'),
11914            name=d.get('name'),
11915            port=d.get('port'),
11916            port_forwarding=d.get('port_forwarding'),
11917            port_override=d.get('port_override'),
11918            public_key=d.get('public_key'),
11919            secret_store_id=d.get('secret_store_id'),
11920            tags=d.get('tags'),
11921            username=d.get('username'),
11922        )
SSH( allow_deprecated_key_exchanges=None, bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, port=None, port_forwarding=None, port_override=None, public_key=None, secret_store_id=None, tags=None, username=None)
11793    def __init__(
11794        self,
11795        allow_deprecated_key_exchanges=None,
11796        bind_interface=None,
11797        egress_filter=None,
11798        healthy=None,
11799        hostname=None,
11800        id=None,
11801        name=None,
11802        port=None,
11803        port_forwarding=None,
11804        port_override=None,
11805        public_key=None,
11806        secret_store_id=None,
11807        tags=None,
11808        username=None,
11809    ):
11810        self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges if allow_deprecated_key_exchanges is not None else False
11811        '''
11812
11813        '''
11814        self.bind_interface = bind_interface if bind_interface is not None else ''
11815        '''
11816         Bind interface
11817        '''
11818        self.egress_filter = egress_filter if egress_filter is not None else ''
11819        '''
11820         A filter applied to the routing logic to pin datasource to nodes.
11821        '''
11822        self.healthy = healthy if healthy is not None else False
11823        '''
11824         True if the datasource is reachable and the credentials are valid.
11825        '''
11826        self.hostname = hostname if hostname is not None else ''
11827        '''
11828
11829        '''
11830        self.id = id if id is not None else ''
11831        '''
11832         Unique identifier of the Resource.
11833        '''
11834        self.name = name if name is not None else ''
11835        '''
11836         Unique human-readable name of the Resource.
11837        '''
11838        self.port = port if port is not None else 0
11839        '''
11840
11841        '''
11842        self.port_forwarding = port_forwarding if port_forwarding is not None else False
11843        '''
11844
11845        '''
11846        self.port_override = port_override if port_override is not None else 0
11847        '''
11848
11849        '''
11850        self.public_key = public_key if public_key is not None else ''
11851        '''
11852
11853        '''
11854        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
11855        '''
11856         ID of the secret store containing credentials for this resource, if any.
11857        '''
11858        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
11859        '''
11860         Tags is a map of key, value pairs.
11861        '''
11862        self.username = username if username is not None else ''
11863        '''
11864
11865        '''
allow_deprecated_key_exchanges
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_forwarding
port_override
public_key
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
11885    def to_dict(self):
11886        return {
11887            'allow_deprecated_key_exchanges':
11888            self.allow_deprecated_key_exchanges,
11889            'bind_interface': self.bind_interface,
11890            'egress_filter': self.egress_filter,
11891            'healthy': self.healthy,
11892            'hostname': self.hostname,
11893            'id': self.id,
11894            'name': self.name,
11895            'port': self.port,
11896            'port_forwarding': self.port_forwarding,
11897            'port_override': self.port_override,
11898            'public_key': self.public_key,
11899            'secret_store_id': self.secret_store_id,
11900            'tags': self.tags,
11901            'username': self.username,
11902        }
@classmethod
def from_dict(cls, d)
11904    @classmethod
11905    def from_dict(cls, d):
11906        return cls(
11907            allow_deprecated_key_exchanges=d.get(
11908                'allow_deprecated_key_exchanges'),
11909            bind_interface=d.get('bind_interface'),
11910            egress_filter=d.get('egress_filter'),
11911            healthy=d.get('healthy'),
11912            hostname=d.get('hostname'),
11913            id=d.get('id'),
11914            name=d.get('name'),
11915            port=d.get('port'),
11916            port_forwarding=d.get('port_forwarding'),
11917            port_override=d.get('port_override'),
11918            public_key=d.get('public_key'),
11919            secret_store_id=d.get('secret_store_id'),
11920            tags=d.get('tags'),
11921            username=d.get('username'),
11922        )
class SSHCert:
11925class SSHCert:
11926    '''
11927
11928    '''
11929    __slots__ = [
11930        'allow_deprecated_key_exchanges',
11931        'bind_interface',
11932        'egress_filter',
11933        'healthy',
11934        'hostname',
11935        'id',
11936        'name',
11937        'port',
11938        'port_forwarding',
11939        'port_override',
11940        'remote_identity_group_id',
11941        'remote_identity_healthcheck_username',
11942        'secret_store_id',
11943        'tags',
11944        'username',
11945    ]
11946
11947    def __init__(
11948        self,
11949        allow_deprecated_key_exchanges=None,
11950        bind_interface=None,
11951        egress_filter=None,
11952        healthy=None,
11953        hostname=None,
11954        id=None,
11955        name=None,
11956        port=None,
11957        port_forwarding=None,
11958        port_override=None,
11959        remote_identity_group_id=None,
11960        remote_identity_healthcheck_username=None,
11961        secret_store_id=None,
11962        tags=None,
11963        username=None,
11964    ):
11965        self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges if allow_deprecated_key_exchanges is not None else False
11966        '''
11967
11968        '''
11969        self.bind_interface = bind_interface if bind_interface is not None else ''
11970        '''
11971         Bind interface
11972        '''
11973        self.egress_filter = egress_filter if egress_filter is not None else ''
11974        '''
11975         A filter applied to the routing logic to pin datasource to nodes.
11976        '''
11977        self.healthy = healthy if healthy is not None else False
11978        '''
11979         True if the datasource is reachable and the credentials are valid.
11980        '''
11981        self.hostname = hostname if hostname is not None else ''
11982        '''
11983
11984        '''
11985        self.id = id if id is not None else ''
11986        '''
11987         Unique identifier of the Resource.
11988        '''
11989        self.name = name if name is not None else ''
11990        '''
11991         Unique human-readable name of the Resource.
11992        '''
11993        self.port = port if port is not None else 0
11994        '''
11995
11996        '''
11997        self.port_forwarding = port_forwarding if port_forwarding is not None else False
11998        '''
11999
12000        '''
12001        self.port_override = port_override if port_override is not None else 0
12002        '''
12003
12004        '''
12005        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
12006        '''
12007
12008        '''
12009        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
12010        '''
12011
12012        '''
12013        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
12014        '''
12015         ID of the secret store containing credentials for this resource, if any.
12016        '''
12017        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12018        '''
12019         Tags is a map of key, value pairs.
12020        '''
12021        self.username = username if username is not None else ''
12022        '''
12023
12024        '''
12025
12026    def __repr__(self):
12027        return '<sdm.SSHCert ' + \
12028            'allow_deprecated_key_exchanges: ' + repr(self.allow_deprecated_key_exchanges) + ' ' +\
12029            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
12030            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
12031            'healthy: ' + repr(self.healthy) + ' ' +\
12032            'hostname: ' + repr(self.hostname) + ' ' +\
12033            'id: ' + repr(self.id) + ' ' +\
12034            'name: ' + repr(self.name) + ' ' +\
12035            'port: ' + repr(self.port) + ' ' +\
12036            'port_forwarding: ' + repr(self.port_forwarding) + ' ' +\
12037            'port_override: ' + repr(self.port_override) + ' ' +\
12038            'remote_identity_group_id: ' + repr(self.remote_identity_group_id) + ' ' +\
12039            'remote_identity_healthcheck_username: ' + repr(self.remote_identity_healthcheck_username) + ' ' +\
12040            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
12041            'tags: ' + repr(self.tags) + ' ' +\
12042            'username: ' + repr(self.username) + ' ' +\
12043            '>'
12044
12045    def to_dict(self):
12046        return {
12047            'allow_deprecated_key_exchanges':
12048            self.allow_deprecated_key_exchanges,
12049            'bind_interface': self.bind_interface,
12050            'egress_filter': self.egress_filter,
12051            'healthy': self.healthy,
12052            'hostname': self.hostname,
12053            'id': self.id,
12054            'name': self.name,
12055            'port': self.port,
12056            'port_forwarding': self.port_forwarding,
12057            'port_override': self.port_override,
12058            'remote_identity_group_id': self.remote_identity_group_id,
12059            'remote_identity_healthcheck_username':
12060            self.remote_identity_healthcheck_username,
12061            'secret_store_id': self.secret_store_id,
12062            'tags': self.tags,
12063            'username': self.username,
12064        }
12065
12066    @classmethod
12067    def from_dict(cls, d):
12068        return cls(
12069            allow_deprecated_key_exchanges=d.get(
12070                'allow_deprecated_key_exchanges'),
12071            bind_interface=d.get('bind_interface'),
12072            egress_filter=d.get('egress_filter'),
12073            healthy=d.get('healthy'),
12074            hostname=d.get('hostname'),
12075            id=d.get('id'),
12076            name=d.get('name'),
12077            port=d.get('port'),
12078            port_forwarding=d.get('port_forwarding'),
12079            port_override=d.get('port_override'),
12080            remote_identity_group_id=d.get('remote_identity_group_id'),
12081            remote_identity_healthcheck_username=d.get(
12082                'remote_identity_healthcheck_username'),
12083            secret_store_id=d.get('secret_store_id'),
12084            tags=d.get('tags'),
12085            username=d.get('username'),
12086        )
SSHCert( allow_deprecated_key_exchanges=None, bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, port=None, port_forwarding=None, port_override=None, remote_identity_group_id=None, remote_identity_healthcheck_username=None, secret_store_id=None, tags=None, username=None)
11947    def __init__(
11948        self,
11949        allow_deprecated_key_exchanges=None,
11950        bind_interface=None,
11951        egress_filter=None,
11952        healthy=None,
11953        hostname=None,
11954        id=None,
11955        name=None,
11956        port=None,
11957        port_forwarding=None,
11958        port_override=None,
11959        remote_identity_group_id=None,
11960        remote_identity_healthcheck_username=None,
11961        secret_store_id=None,
11962        tags=None,
11963        username=None,
11964    ):
11965        self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges if allow_deprecated_key_exchanges is not None else False
11966        '''
11967
11968        '''
11969        self.bind_interface = bind_interface if bind_interface is not None else ''
11970        '''
11971         Bind interface
11972        '''
11973        self.egress_filter = egress_filter if egress_filter is not None else ''
11974        '''
11975         A filter applied to the routing logic to pin datasource to nodes.
11976        '''
11977        self.healthy = healthy if healthy is not None else False
11978        '''
11979         True if the datasource is reachable and the credentials are valid.
11980        '''
11981        self.hostname = hostname if hostname is not None else ''
11982        '''
11983
11984        '''
11985        self.id = id if id is not None else ''
11986        '''
11987         Unique identifier of the Resource.
11988        '''
11989        self.name = name if name is not None else ''
11990        '''
11991         Unique human-readable name of the Resource.
11992        '''
11993        self.port = port if port is not None else 0
11994        '''
11995
11996        '''
11997        self.port_forwarding = port_forwarding if port_forwarding is not None else False
11998        '''
11999
12000        '''
12001        self.port_override = port_override if port_override is not None else 0
12002        '''
12003
12004        '''
12005        self.remote_identity_group_id = remote_identity_group_id if remote_identity_group_id is not None else ''
12006        '''
12007
12008        '''
12009        self.remote_identity_healthcheck_username = remote_identity_healthcheck_username if remote_identity_healthcheck_username is not None else ''
12010        '''
12011
12012        '''
12013        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
12014        '''
12015         ID of the secret store containing credentials for this resource, if any.
12016        '''
12017        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12018        '''
12019         Tags is a map of key, value pairs.
12020        '''
12021        self.username = username if username is not None else ''
12022        '''
12023
12024        '''
allow_deprecated_key_exchanges
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_forwarding
port_override
remote_identity_group_id
remote_identity_healthcheck_username
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
12045    def to_dict(self):
12046        return {
12047            'allow_deprecated_key_exchanges':
12048            self.allow_deprecated_key_exchanges,
12049            'bind_interface': self.bind_interface,
12050            'egress_filter': self.egress_filter,
12051            'healthy': self.healthy,
12052            'hostname': self.hostname,
12053            'id': self.id,
12054            'name': self.name,
12055            'port': self.port,
12056            'port_forwarding': self.port_forwarding,
12057            'port_override': self.port_override,
12058            'remote_identity_group_id': self.remote_identity_group_id,
12059            'remote_identity_healthcheck_username':
12060            self.remote_identity_healthcheck_username,
12061            'secret_store_id': self.secret_store_id,
12062            'tags': self.tags,
12063            'username': self.username,
12064        }
@classmethod
def from_dict(cls, d)
12066    @classmethod
12067    def from_dict(cls, d):
12068        return cls(
12069            allow_deprecated_key_exchanges=d.get(
12070                'allow_deprecated_key_exchanges'),
12071            bind_interface=d.get('bind_interface'),
12072            egress_filter=d.get('egress_filter'),
12073            healthy=d.get('healthy'),
12074            hostname=d.get('hostname'),
12075            id=d.get('id'),
12076            name=d.get('name'),
12077            port=d.get('port'),
12078            port_forwarding=d.get('port_forwarding'),
12079            port_override=d.get('port_override'),
12080            remote_identity_group_id=d.get('remote_identity_group_id'),
12081            remote_identity_healthcheck_username=d.get(
12082                'remote_identity_healthcheck_username'),
12083            secret_store_id=d.get('secret_store_id'),
12084            tags=d.get('tags'),
12085            username=d.get('username'),
12086        )
class SSHCustomerKey:
12089class SSHCustomerKey:
12090    '''
12091
12092    '''
12093    __slots__ = [
12094        'allow_deprecated_key_exchanges',
12095        'bind_interface',
12096        'egress_filter',
12097        'healthy',
12098        'hostname',
12099        'id',
12100        'name',
12101        'port',
12102        'port_forwarding',
12103        'port_override',
12104        'private_key',
12105        'secret_store_id',
12106        'tags',
12107        'username',
12108    ]
12109
12110    def __init__(
12111        self,
12112        allow_deprecated_key_exchanges=None,
12113        bind_interface=None,
12114        egress_filter=None,
12115        healthy=None,
12116        hostname=None,
12117        id=None,
12118        name=None,
12119        port=None,
12120        port_forwarding=None,
12121        port_override=None,
12122        private_key=None,
12123        secret_store_id=None,
12124        tags=None,
12125        username=None,
12126    ):
12127        self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges if allow_deprecated_key_exchanges is not None else False
12128        '''
12129
12130        '''
12131        self.bind_interface = bind_interface if bind_interface is not None else ''
12132        '''
12133         Bind interface
12134        '''
12135        self.egress_filter = egress_filter if egress_filter is not None else ''
12136        '''
12137         A filter applied to the routing logic to pin datasource to nodes.
12138        '''
12139        self.healthy = healthy if healthy is not None else False
12140        '''
12141         True if the datasource is reachable and the credentials are valid.
12142        '''
12143        self.hostname = hostname if hostname is not None else ''
12144        '''
12145
12146        '''
12147        self.id = id if id is not None else ''
12148        '''
12149         Unique identifier of the Resource.
12150        '''
12151        self.name = name if name is not None else ''
12152        '''
12153         Unique human-readable name of the Resource.
12154        '''
12155        self.port = port if port is not None else 0
12156        '''
12157
12158        '''
12159        self.port_forwarding = port_forwarding if port_forwarding is not None else False
12160        '''
12161
12162        '''
12163        self.port_override = port_override if port_override is not None else 0
12164        '''
12165
12166        '''
12167        self.private_key = private_key if private_key is not None else ''
12168        '''
12169
12170        '''
12171        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
12172        '''
12173         ID of the secret store containing credentials for this resource, if any.
12174        '''
12175        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12176        '''
12177         Tags is a map of key, value pairs.
12178        '''
12179        self.username = username if username is not None else ''
12180        '''
12181
12182        '''
12183
12184    def __repr__(self):
12185        return '<sdm.SSHCustomerKey ' + \
12186            'allow_deprecated_key_exchanges: ' + repr(self.allow_deprecated_key_exchanges) + ' ' +\
12187            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
12188            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
12189            'healthy: ' + repr(self.healthy) + ' ' +\
12190            'hostname: ' + repr(self.hostname) + ' ' +\
12191            'id: ' + repr(self.id) + ' ' +\
12192            'name: ' + repr(self.name) + ' ' +\
12193            'port: ' + repr(self.port) + ' ' +\
12194            'port_forwarding: ' + repr(self.port_forwarding) + ' ' +\
12195            'port_override: ' + repr(self.port_override) + ' ' +\
12196            'private_key: ' + repr(self.private_key) + ' ' +\
12197            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
12198            'tags: ' + repr(self.tags) + ' ' +\
12199            'username: ' + repr(self.username) + ' ' +\
12200            '>'
12201
12202    def to_dict(self):
12203        return {
12204            'allow_deprecated_key_exchanges':
12205            self.allow_deprecated_key_exchanges,
12206            'bind_interface': self.bind_interface,
12207            'egress_filter': self.egress_filter,
12208            'healthy': self.healthy,
12209            'hostname': self.hostname,
12210            'id': self.id,
12211            'name': self.name,
12212            'port': self.port,
12213            'port_forwarding': self.port_forwarding,
12214            'port_override': self.port_override,
12215            'private_key': self.private_key,
12216            'secret_store_id': self.secret_store_id,
12217            'tags': self.tags,
12218            'username': self.username,
12219        }
12220
12221    @classmethod
12222    def from_dict(cls, d):
12223        return cls(
12224            allow_deprecated_key_exchanges=d.get(
12225                'allow_deprecated_key_exchanges'),
12226            bind_interface=d.get('bind_interface'),
12227            egress_filter=d.get('egress_filter'),
12228            healthy=d.get('healthy'),
12229            hostname=d.get('hostname'),
12230            id=d.get('id'),
12231            name=d.get('name'),
12232            port=d.get('port'),
12233            port_forwarding=d.get('port_forwarding'),
12234            port_override=d.get('port_override'),
12235            private_key=d.get('private_key'),
12236            secret_store_id=d.get('secret_store_id'),
12237            tags=d.get('tags'),
12238            username=d.get('username'),
12239        )
SSHCustomerKey( allow_deprecated_key_exchanges=None, bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, port=None, port_forwarding=None, port_override=None, private_key=None, secret_store_id=None, tags=None, username=None)
12110    def __init__(
12111        self,
12112        allow_deprecated_key_exchanges=None,
12113        bind_interface=None,
12114        egress_filter=None,
12115        healthy=None,
12116        hostname=None,
12117        id=None,
12118        name=None,
12119        port=None,
12120        port_forwarding=None,
12121        port_override=None,
12122        private_key=None,
12123        secret_store_id=None,
12124        tags=None,
12125        username=None,
12126    ):
12127        self.allow_deprecated_key_exchanges = allow_deprecated_key_exchanges if allow_deprecated_key_exchanges is not None else False
12128        '''
12129
12130        '''
12131        self.bind_interface = bind_interface if bind_interface is not None else ''
12132        '''
12133         Bind interface
12134        '''
12135        self.egress_filter = egress_filter if egress_filter is not None else ''
12136        '''
12137         A filter applied to the routing logic to pin datasource to nodes.
12138        '''
12139        self.healthy = healthy if healthy is not None else False
12140        '''
12141         True if the datasource is reachable and the credentials are valid.
12142        '''
12143        self.hostname = hostname if hostname is not None else ''
12144        '''
12145
12146        '''
12147        self.id = id if id is not None else ''
12148        '''
12149         Unique identifier of the Resource.
12150        '''
12151        self.name = name if name is not None else ''
12152        '''
12153         Unique human-readable name of the Resource.
12154        '''
12155        self.port = port if port is not None else 0
12156        '''
12157
12158        '''
12159        self.port_forwarding = port_forwarding if port_forwarding is not None else False
12160        '''
12161
12162        '''
12163        self.port_override = port_override if port_override is not None else 0
12164        '''
12165
12166        '''
12167        self.private_key = private_key if private_key is not None else ''
12168        '''
12169
12170        '''
12171        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
12172        '''
12173         ID of the secret store containing credentials for this resource, if any.
12174        '''
12175        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12176        '''
12177         Tags is a map of key, value pairs.
12178        '''
12179        self.username = username if username is not None else ''
12180        '''
12181
12182        '''
allow_deprecated_key_exchanges
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

port
port_forwarding
port_override
private_key
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
12202    def to_dict(self):
12203        return {
12204            'allow_deprecated_key_exchanges':
12205            self.allow_deprecated_key_exchanges,
12206            'bind_interface': self.bind_interface,
12207            'egress_filter': self.egress_filter,
12208            'healthy': self.healthy,
12209            'hostname': self.hostname,
12210            'id': self.id,
12211            'name': self.name,
12212            'port': self.port,
12213            'port_forwarding': self.port_forwarding,
12214            'port_override': self.port_override,
12215            'private_key': self.private_key,
12216            'secret_store_id': self.secret_store_id,
12217            'tags': self.tags,
12218            'username': self.username,
12219        }
@classmethod
def from_dict(cls, d)
12221    @classmethod
12222    def from_dict(cls, d):
12223        return cls(
12224            allow_deprecated_key_exchanges=d.get(
12225                'allow_deprecated_key_exchanges'),
12226            bind_interface=d.get('bind_interface'),
12227            egress_filter=d.get('egress_filter'),
12228            healthy=d.get('healthy'),
12229            hostname=d.get('hostname'),
12230            id=d.get('id'),
12231            name=d.get('name'),
12232            port=d.get('port'),
12233            port_forwarding=d.get('port_forwarding'),
12234            port_override=d.get('port_override'),
12235            private_key=d.get('private_key'),
12236            secret_store_id=d.get('secret_store_id'),
12237            tags=d.get('tags'),
12238            username=d.get('username'),
12239        )
class SecretStoreCreateResponse:
12242class SecretStoreCreateResponse:
12243    '''
12244     SecretStoreCreateResponse reports how the SecretStores were created in the system.
12245    '''
12246    __slots__ = [
12247        'meta',
12248        'rate_limit',
12249        'secret_store',
12250    ]
12251
12252    def __init__(
12253        self,
12254        meta=None,
12255        rate_limit=None,
12256        secret_store=None,
12257    ):
12258        self.meta = meta if meta is not None else None
12259        '''
12260         Reserved for future use.
12261        '''
12262        self.rate_limit = rate_limit if rate_limit is not None else None
12263        '''
12264         Rate limit information.
12265        '''
12266        self.secret_store = secret_store if secret_store is not None else None
12267        '''
12268         The created SecretStore.
12269        '''
12270
12271    def __repr__(self):
12272        return '<sdm.SecretStoreCreateResponse ' + \
12273            'meta: ' + repr(self.meta) + ' ' +\
12274            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
12275            'secret_store: ' + repr(self.secret_store) + ' ' +\
12276            '>'
12277
12278    def to_dict(self):
12279        return {
12280            'meta': self.meta,
12281            'rate_limit': self.rate_limit,
12282            'secret_store': self.secret_store,
12283        }
12284
12285    @classmethod
12286    def from_dict(cls, d):
12287        return cls(
12288            meta=d.get('meta'),
12289            rate_limit=d.get('rate_limit'),
12290            secret_store=d.get('secret_store'),
12291        )

SecretStoreCreateResponse reports how the SecretStores were created in the system.

SecretStoreCreateResponse(meta=None, rate_limit=None, secret_store=None)
12252    def __init__(
12253        self,
12254        meta=None,
12255        rate_limit=None,
12256        secret_store=None,
12257    ):
12258        self.meta = meta if meta is not None else None
12259        '''
12260         Reserved for future use.
12261        '''
12262        self.rate_limit = rate_limit if rate_limit is not None else None
12263        '''
12264         Rate limit information.
12265        '''
12266        self.secret_store = secret_store if secret_store is not None else None
12267        '''
12268         The created SecretStore.
12269        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

secret_store

The created SecretStore.

def to_dict(self)
12278    def to_dict(self):
12279        return {
12280            'meta': self.meta,
12281            'rate_limit': self.rate_limit,
12282            'secret_store': self.secret_store,
12283        }
@classmethod
def from_dict(cls, d)
12285    @classmethod
12286    def from_dict(cls, d):
12287        return cls(
12288            meta=d.get('meta'),
12289            rate_limit=d.get('rate_limit'),
12290            secret_store=d.get('secret_store'),
12291        )
class SecretStoreDeleteResponse:
12294class SecretStoreDeleteResponse:
12295    '''
12296     SecretStoreDeleteResponse returns information about a SecretStore that was deleted.
12297    '''
12298    __slots__ = [
12299        'meta',
12300        'rate_limit',
12301    ]
12302
12303    def __init__(
12304        self,
12305        meta=None,
12306        rate_limit=None,
12307    ):
12308        self.meta = meta if meta is not None else None
12309        '''
12310         Reserved for future use.
12311        '''
12312        self.rate_limit = rate_limit if rate_limit is not None else None
12313        '''
12314         Rate limit information.
12315        '''
12316
12317    def __repr__(self):
12318        return '<sdm.SecretStoreDeleteResponse ' + \
12319            'meta: ' + repr(self.meta) + ' ' +\
12320            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
12321            '>'
12322
12323    def to_dict(self):
12324        return {
12325            'meta': self.meta,
12326            'rate_limit': self.rate_limit,
12327        }
12328
12329    @classmethod
12330    def from_dict(cls, d):
12331        return cls(
12332            meta=d.get('meta'),
12333            rate_limit=d.get('rate_limit'),
12334        )

SecretStoreDeleteResponse returns information about a SecretStore that was deleted.

SecretStoreDeleteResponse(meta=None, rate_limit=None)
12303    def __init__(
12304        self,
12305        meta=None,
12306        rate_limit=None,
12307    ):
12308        self.meta = meta if meta is not None else None
12309        '''
12310         Reserved for future use.
12311        '''
12312        self.rate_limit = rate_limit if rate_limit is not None else None
12313        '''
12314         Rate limit information.
12315        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

def to_dict(self)
12323    def to_dict(self):
12324        return {
12325            'meta': self.meta,
12326            'rate_limit': self.rate_limit,
12327        }
@classmethod
def from_dict(cls, d)
12329    @classmethod
12330    def from_dict(cls, d):
12331        return cls(
12332            meta=d.get('meta'),
12333            rate_limit=d.get('rate_limit'),
12334        )
class SecretStoreGetResponse:
12337class SecretStoreGetResponse:
12338    '''
12339     SecretStoreGetResponse returns a requested SecretStore.
12340    '''
12341    __slots__ = [
12342        'meta',
12343        'rate_limit',
12344        'secret_store',
12345    ]
12346
12347    def __init__(
12348        self,
12349        meta=None,
12350        rate_limit=None,
12351        secret_store=None,
12352    ):
12353        self.meta = meta if meta is not None else None
12354        '''
12355         Reserved for future use.
12356        '''
12357        self.rate_limit = rate_limit if rate_limit is not None else None
12358        '''
12359         Rate limit information.
12360        '''
12361        self.secret_store = secret_store if secret_store is not None else None
12362        '''
12363         The requested SecretStore.
12364        '''
12365
12366    def __repr__(self):
12367        return '<sdm.SecretStoreGetResponse ' + \
12368            'meta: ' + repr(self.meta) + ' ' +\
12369            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
12370            'secret_store: ' + repr(self.secret_store) + ' ' +\
12371            '>'
12372
12373    def to_dict(self):
12374        return {
12375            'meta': self.meta,
12376            'rate_limit': self.rate_limit,
12377            'secret_store': self.secret_store,
12378        }
12379
12380    @classmethod
12381    def from_dict(cls, d):
12382        return cls(
12383            meta=d.get('meta'),
12384            rate_limit=d.get('rate_limit'),
12385            secret_store=d.get('secret_store'),
12386        )

SecretStoreGetResponse returns a requested SecretStore.

SecretStoreGetResponse(meta=None, rate_limit=None, secret_store=None)
12347    def __init__(
12348        self,
12349        meta=None,
12350        rate_limit=None,
12351        secret_store=None,
12352    ):
12353        self.meta = meta if meta is not None else None
12354        '''
12355         Reserved for future use.
12356        '''
12357        self.rate_limit = rate_limit if rate_limit is not None else None
12358        '''
12359         Rate limit information.
12360        '''
12361        self.secret_store = secret_store if secret_store is not None else None
12362        '''
12363         The requested SecretStore.
12364        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

secret_store

The requested SecretStore.

def to_dict(self)
12373    def to_dict(self):
12374        return {
12375            'meta': self.meta,
12376            'rate_limit': self.rate_limit,
12377            'secret_store': self.secret_store,
12378        }
@classmethod
def from_dict(cls, d)
12380    @classmethod
12381    def from_dict(cls, d):
12382        return cls(
12383            meta=d.get('meta'),
12384            rate_limit=d.get('rate_limit'),
12385            secret_store=d.get('secret_store'),
12386        )
class SecretStoreUpdateResponse:
12389class SecretStoreUpdateResponse:
12390    '''
12391     SecretStoreUpdateResponse returns the fields of a SecretStore after it has been updated by
12392     a SecretStoreUpdateRequest.
12393    '''
12394    __slots__ = [
12395        'meta',
12396        'rate_limit',
12397        'secret_store',
12398    ]
12399
12400    def __init__(
12401        self,
12402        meta=None,
12403        rate_limit=None,
12404        secret_store=None,
12405    ):
12406        self.meta = meta if meta is not None else None
12407        '''
12408         Reserved for future use.
12409        '''
12410        self.rate_limit = rate_limit if rate_limit is not None else None
12411        '''
12412         Rate limit information.
12413        '''
12414        self.secret_store = secret_store if secret_store is not None else None
12415        '''
12416         The updated SecretStore.
12417        '''
12418
12419    def __repr__(self):
12420        return '<sdm.SecretStoreUpdateResponse ' + \
12421            'meta: ' + repr(self.meta) + ' ' +\
12422            'rate_limit: ' + repr(self.rate_limit) + ' ' +\
12423            'secret_store: ' + repr(self.secret_store) + ' ' +\
12424            '>'
12425
12426    def to_dict(self):
12427        return {
12428            'meta': self.meta,
12429            'rate_limit': self.rate_limit,
12430            'secret_store': self.secret_store,
12431        }
12432
12433    @classmethod
12434    def from_dict(cls, d):
12435        return cls(
12436            meta=d.get('meta'),
12437            rate_limit=d.get('rate_limit'),
12438            secret_store=d.get('secret_store'),
12439        )

SecretStoreUpdateResponse returns the fields of a SecretStore after it has been updated by a SecretStoreUpdateRequest.

SecretStoreUpdateResponse(meta=None, rate_limit=None, secret_store=None)
12400    def __init__(
12401        self,
12402        meta=None,
12403        rate_limit=None,
12404        secret_store=None,
12405    ):
12406        self.meta = meta if meta is not None else None
12407        '''
12408         Reserved for future use.
12409        '''
12410        self.rate_limit = rate_limit if rate_limit is not None else None
12411        '''
12412         Rate limit information.
12413        '''
12414        self.secret_store = secret_store if secret_store is not None else None
12415        '''
12416         The updated SecretStore.
12417        '''
meta

Reserved for future use.

rate_limit

Rate limit information.

secret_store

The updated SecretStore.

def to_dict(self)
12426    def to_dict(self):
12427        return {
12428            'meta': self.meta,
12429            'rate_limit': self.rate_limit,
12430            'secret_store': self.secret_store,
12431        }
@classmethod
def from_dict(cls, d)
12433    @classmethod
12434    def from_dict(cls, d):
12435        return cls(
12436            meta=d.get('meta'),
12437            rate_limit=d.get('rate_limit'),
12438            secret_store=d.get('secret_store'),
12439        )
class Service:
12442class Service:
12443    '''
12444     A Service is a service account that can connect to resources they are granted
12445     directly, or granted via roles. Services are typically automated jobs.
12446    '''
12447    __slots__ = [
12448        'id',
12449        'name',
12450        'suspended',
12451        'tags',
12452    ]
12453
12454    def __init__(
12455        self,
12456        id=None,
12457        name=None,
12458        suspended=None,
12459        tags=None,
12460    ):
12461        self.id = id if id is not None else ''
12462        '''
12463         Unique identifier of the Service.
12464        '''
12465        self.name = name if name is not None else ''
12466        '''
12467         Unique human-readable name of the Service.
12468        '''
12469        self.suspended = suspended if suspended is not None else False
12470        '''
12471         The Service's suspended state.
12472        '''
12473        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12474        '''
12475         Tags is a map of key, value pairs.
12476        '''
12477
12478    def __repr__(self):
12479        return '<sdm.Service ' + \
12480            'id: ' + repr(self.id) + ' ' +\
12481            'name: ' + repr(self.name) + ' ' +\
12482            'suspended: ' + repr(self.suspended) + ' ' +\
12483            'tags: ' + repr(self.tags) + ' ' +\
12484            '>'
12485
12486    def to_dict(self):
12487        return {
12488            'id': self.id,
12489            'name': self.name,
12490            'suspended': self.suspended,
12491            'tags': self.tags,
12492        }
12493
12494    @classmethod
12495    def from_dict(cls, d):
12496        return cls(
12497            id=d.get('id'),
12498            name=d.get('name'),
12499            suspended=d.get('suspended'),
12500            tags=d.get('tags'),
12501        )

A Service is a service account that can connect to resources they are granted directly, or granted via roles. Services are typically automated jobs.

Service(id=None, name=None, suspended=None, tags=None)
12454    def __init__(
12455        self,
12456        id=None,
12457        name=None,
12458        suspended=None,
12459        tags=None,
12460    ):
12461        self.id = id if id is not None else ''
12462        '''
12463         Unique identifier of the Service.
12464        '''
12465        self.name = name if name is not None else ''
12466        '''
12467         Unique human-readable name of the Service.
12468        '''
12469        self.suspended = suspended if suspended is not None else False
12470        '''
12471         The Service's suspended state.
12472        '''
12473        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12474        '''
12475         Tags is a map of key, value pairs.
12476        '''
id

Unique identifier of the Service.

name

Unique human-readable name of the Service.

suspended

The Service's suspended state.

tags

Tags is a map of key, value pairs.

def to_dict(self)
12486    def to_dict(self):
12487        return {
12488            'id': self.id,
12489            'name': self.name,
12490            'suspended': self.suspended,
12491            'tags': self.tags,
12492        }
@classmethod
def from_dict(cls, d)
12494    @classmethod
12495    def from_dict(cls, d):
12496        return cls(
12497            id=d.get('id'),
12498            name=d.get('name'),
12499            suspended=d.get('suspended'),
12500            tags=d.get('tags'),
12501        )
class SingleStore:
12504class SingleStore:
12505    '''
12506
12507    '''
12508    __slots__ = [
12509        'bind_interface',
12510        'database',
12511        'egress_filter',
12512        'healthy',
12513        'hostname',
12514        'id',
12515        'name',
12516        'password',
12517        'port',
12518        'port_override',
12519        'secret_store_id',
12520        'tags',
12521        'username',
12522    ]
12523
12524    def __init__(
12525        self,
12526        bind_interface=None,
12527        database=None,
12528        egress_filter=None,
12529        healthy=None,
12530        hostname=None,
12531        id=None,
12532        name=None,
12533        password=None,
12534        port=None,
12535        port_override=None,
12536        secret_store_id=None,
12537        tags=None,
12538        username=None,
12539    ):
12540        self.bind_interface = bind_interface if bind_interface is not None else ''
12541        '''
12542         Bind interface
12543        '''
12544        self.database = database if database is not None else ''
12545        '''
12546
12547        '''
12548        self.egress_filter = egress_filter if egress_filter is not None else ''
12549        '''
12550         A filter applied to the routing logic to pin datasource to nodes.
12551        '''
12552        self.healthy = healthy if healthy is not None else False
12553        '''
12554         True if the datasource is reachable and the credentials are valid.
12555        '''
12556        self.hostname = hostname if hostname is not None else ''
12557        '''
12558
12559        '''
12560        self.id = id if id is not None else ''
12561        '''
12562         Unique identifier of the Resource.
12563        '''
12564        self.name = name if name is not None else ''
12565        '''
12566         Unique human-readable name of the Resource.
12567        '''
12568        self.password = password if password is not None else ''
12569        '''
12570
12571        '''
12572        self.port = port if port is not None else 0
12573        '''
12574
12575        '''
12576        self.port_override = port_override if port_override is not None else 0
12577        '''
12578
12579        '''
12580        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
12581        '''
12582         ID of the secret store containing credentials for this resource, if any.
12583        '''
12584        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12585        '''
12586         Tags is a map of key, value pairs.
12587        '''
12588        self.username = username if username is not None else ''
12589        '''
12590
12591        '''
12592
12593    def __repr__(self):
12594        return '<sdm.SingleStore ' + \
12595            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
12596            'database: ' + repr(self.database) + ' ' +\
12597            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
12598            'healthy: ' + repr(self.healthy) + ' ' +\
12599            'hostname: ' + repr(self.hostname) + ' ' +\
12600            'id: ' + repr(self.id) + ' ' +\
12601            'name: ' + repr(self.name) + ' ' +\
12602            'password: ' + repr(self.password) + ' ' +\
12603            'port: ' + repr(self.port) + ' ' +\
12604            'port_override: ' + repr(self.port_override) + ' ' +\
12605            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
12606            'tags: ' + repr(self.tags) + ' ' +\
12607            'username: ' + repr(self.username) + ' ' +\
12608            '>'
12609
12610    def to_dict(self):
12611        return {
12612            'bind_interface': self.bind_interface,
12613            'database': self.database,
12614            'egress_filter': self.egress_filter,
12615            'healthy': self.healthy,
12616            'hostname': self.hostname,
12617            'id': self.id,
12618            'name': self.name,
12619            'password': self.password,
12620            'port': self.port,
12621            'port_override': self.port_override,
12622            'secret_store_id': self.secret_store_id,
12623            'tags': self.tags,
12624            'username': self.username,
12625        }
12626
12627    @classmethod
12628    def from_dict(cls, d):
12629        return cls(
12630            bind_interface=d.get('bind_interface'),
12631            database=d.get('database'),
12632            egress_filter=d.get('egress_filter'),
12633            healthy=d.get('healthy'),
12634            hostname=d.get('hostname'),
12635            id=d.get('id'),
12636            name=d.get('name'),
12637            password=d.get('password'),
12638            port=d.get('port'),
12639            port_override=d.get('port_override'),
12640            secret_store_id=d.get('secret_store_id'),
12641            tags=d.get('tags'),
12642            username=d.get('username'),
12643        )
SingleStore( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
12524    def __init__(
12525        self,
12526        bind_interface=None,
12527        database=None,
12528        egress_filter=None,
12529        healthy=None,
12530        hostname=None,
12531        id=None,
12532        name=None,
12533        password=None,
12534        port=None,
12535        port_override=None,
12536        secret_store_id=None,
12537        tags=None,
12538        username=None,
12539    ):
12540        self.bind_interface = bind_interface if bind_interface is not None else ''
12541        '''
12542         Bind interface
12543        '''
12544        self.database = database if database is not None else ''
12545        '''
12546
12547        '''
12548        self.egress_filter = egress_filter if egress_filter is not None else ''
12549        '''
12550         A filter applied to the routing logic to pin datasource to nodes.
12551        '''
12552        self.healthy = healthy if healthy is not None else False
12553        '''
12554         True if the datasource is reachable and the credentials are valid.
12555        '''
12556        self.hostname = hostname if hostname is not None else ''
12557        '''
12558
12559        '''
12560        self.id = id if id is not None else ''
12561        '''
12562         Unique identifier of the Resource.
12563        '''
12564        self.name = name if name is not None else ''
12565        '''
12566         Unique human-readable name of the Resource.
12567        '''
12568        self.password = password if password is not None else ''
12569        '''
12570
12571        '''
12572        self.port = port if port is not None else 0
12573        '''
12574
12575        '''
12576        self.port_override = port_override if port_override is not None else 0
12577        '''
12578
12579        '''
12580        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
12581        '''
12582         ID of the secret store containing credentials for this resource, if any.
12583        '''
12584        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12585        '''
12586         Tags is a map of key, value pairs.
12587        '''
12588        self.username = username if username is not None else ''
12589        '''
12590
12591        '''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
12610    def to_dict(self):
12611        return {
12612            'bind_interface': self.bind_interface,
12613            'database': self.database,
12614            'egress_filter': self.egress_filter,
12615            'healthy': self.healthy,
12616            'hostname': self.hostname,
12617            'id': self.id,
12618            'name': self.name,
12619            'password': self.password,
12620            'port': self.port,
12621            'port_override': self.port_override,
12622            'secret_store_id': self.secret_store_id,
12623            'tags': self.tags,
12624            'username': self.username,
12625        }
@classmethod
def from_dict(cls, d)
12627    @classmethod
12628    def from_dict(cls, d):
12629        return cls(
12630            bind_interface=d.get('bind_interface'),
12631            database=d.get('database'),
12632            egress_filter=d.get('egress_filter'),
12633            healthy=d.get('healthy'),
12634            hostname=d.get('hostname'),
12635            id=d.get('id'),
12636            name=d.get('name'),
12637            password=d.get('password'),
12638            port=d.get('port'),
12639            port_override=d.get('port_override'),
12640            secret_store_id=d.get('secret_store_id'),
12641            tags=d.get('tags'),
12642            username=d.get('username'),
12643        )
class Snowflake:
12646class Snowflake:
12647    '''
12648
12649    '''
12650    __slots__ = [
12651        'bind_interface',
12652        'database',
12653        'egress_filter',
12654        'healthy',
12655        'hostname',
12656        'id',
12657        'name',
12658        'password',
12659        'port_override',
12660        'schema',
12661        'secret_store_id',
12662        'tags',
12663        'username',
12664    ]
12665
12666    def __init__(
12667        self,
12668        bind_interface=None,
12669        database=None,
12670        egress_filter=None,
12671        healthy=None,
12672        hostname=None,
12673        id=None,
12674        name=None,
12675        password=None,
12676        port_override=None,
12677        schema=None,
12678        secret_store_id=None,
12679        tags=None,
12680        username=None,
12681    ):
12682        self.bind_interface = bind_interface if bind_interface is not None else ''
12683        '''
12684         Bind interface
12685        '''
12686        self.database = database if database is not None else ''
12687        '''
12688
12689        '''
12690        self.egress_filter = egress_filter if egress_filter is not None else ''
12691        '''
12692         A filter applied to the routing logic to pin datasource to nodes.
12693        '''
12694        self.healthy = healthy if healthy is not None else False
12695        '''
12696         True if the datasource is reachable and the credentials are valid.
12697        '''
12698        self.hostname = hostname if hostname is not None else ''
12699        '''
12700
12701        '''
12702        self.id = id if id is not None else ''
12703        '''
12704         Unique identifier of the Resource.
12705        '''
12706        self.name = name if name is not None else ''
12707        '''
12708         Unique human-readable name of the Resource.
12709        '''
12710        self.password = password if password is not None else ''
12711        '''
12712
12713        '''
12714        self.port_override = port_override if port_override is not None else 0
12715        '''
12716
12717        '''
12718        self.schema = schema if schema is not None else ''
12719        '''
12720
12721        '''
12722        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
12723        '''
12724         ID of the secret store containing credentials for this resource, if any.
12725        '''
12726        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12727        '''
12728         Tags is a map of key, value pairs.
12729        '''
12730        self.username = username if username is not None else ''
12731        '''
12732
12733        '''
12734
12735    def __repr__(self):
12736        return '<sdm.Snowflake ' + \
12737            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
12738            'database: ' + repr(self.database) + ' ' +\
12739            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
12740            'healthy: ' + repr(self.healthy) + ' ' +\
12741            'hostname: ' + repr(self.hostname) + ' ' +\
12742            'id: ' + repr(self.id) + ' ' +\
12743            'name: ' + repr(self.name) + ' ' +\
12744            'password: ' + repr(self.password) + ' ' +\
12745            'port_override: ' + repr(self.port_override) + ' ' +\
12746            'schema: ' + repr(self.schema) + ' ' +\
12747            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
12748            'tags: ' + repr(self.tags) + ' ' +\
12749            'username: ' + repr(self.username) + ' ' +\
12750            '>'
12751
12752    def to_dict(self):
12753        return {
12754            'bind_interface': self.bind_interface,
12755            'database': self.database,
12756            'egress_filter': self.egress_filter,
12757            'healthy': self.healthy,
12758            'hostname': self.hostname,
12759            'id': self.id,
12760            'name': self.name,
12761            'password': self.password,
12762            'port_override': self.port_override,
12763            'schema': self.schema,
12764            'secret_store_id': self.secret_store_id,
12765            'tags': self.tags,
12766            'username': self.username,
12767        }
12768
12769    @classmethod
12770    def from_dict(cls, d):
12771        return cls(
12772            bind_interface=d.get('bind_interface'),
12773            database=d.get('database'),
12774            egress_filter=d.get('egress_filter'),
12775            healthy=d.get('healthy'),
12776            hostname=d.get('hostname'),
12777            id=d.get('id'),
12778            name=d.get('name'),
12779            password=d.get('password'),
12780            port_override=d.get('port_override'),
12781            schema=d.get('schema'),
12782            secret_store_id=d.get('secret_store_id'),
12783            tags=d.get('tags'),
12784            username=d.get('username'),
12785        )
Snowflake( bind_interface=None, database=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port_override=None, schema=None, secret_store_id=None, tags=None, username=None)
12666    def __init__(
12667        self,
12668        bind_interface=None,
12669        database=None,
12670        egress_filter=None,
12671        healthy=None,
12672        hostname=None,
12673        id=None,
12674        name=None,
12675        password=None,
12676        port_override=None,
12677        schema=None,
12678        secret_store_id=None,
12679        tags=None,
12680        username=None,
12681    ):
12682        self.bind_interface = bind_interface if bind_interface is not None else ''
12683        '''
12684         Bind interface
12685        '''
12686        self.database = database if database is not None else ''
12687        '''
12688
12689        '''
12690        self.egress_filter = egress_filter if egress_filter is not None else ''
12691        '''
12692         A filter applied to the routing logic to pin datasource to nodes.
12693        '''
12694        self.healthy = healthy if healthy is not None else False
12695        '''
12696         True if the datasource is reachable and the credentials are valid.
12697        '''
12698        self.hostname = hostname if hostname is not None else ''
12699        '''
12700
12701        '''
12702        self.id = id if id is not None else ''
12703        '''
12704         Unique identifier of the Resource.
12705        '''
12706        self.name = name if name is not None else ''
12707        '''
12708         Unique human-readable name of the Resource.
12709        '''
12710        self.password = password if password is not None else ''
12711        '''
12712
12713        '''
12714        self.port_override = port_override if port_override is not None else 0
12715        '''
12716
12717        '''
12718        self.schema = schema if schema is not None else ''
12719        '''
12720
12721        '''
12722        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
12723        '''
12724         ID of the secret store containing credentials for this resource, if any.
12725        '''
12726        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12727        '''
12728         Tags is a map of key, value pairs.
12729        '''
12730        self.username = username if username is not None else ''
12731        '''
12732
12733        '''
bind_interface

Bind interface

database
egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port_override
schema
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
12752    def to_dict(self):
12753        return {
12754            'bind_interface': self.bind_interface,
12755            'database': self.database,
12756            'egress_filter': self.egress_filter,
12757            'healthy': self.healthy,
12758            'hostname': self.hostname,
12759            'id': self.id,
12760            'name': self.name,
12761            'password': self.password,
12762            'port_override': self.port_override,
12763            'schema': self.schema,
12764            'secret_store_id': self.secret_store_id,
12765            'tags': self.tags,
12766            'username': self.username,
12767        }
@classmethod
def from_dict(cls, d)
12769    @classmethod
12770    def from_dict(cls, d):
12771        return cls(
12772            bind_interface=d.get('bind_interface'),
12773            database=d.get('database'),
12774            egress_filter=d.get('egress_filter'),
12775            healthy=d.get('healthy'),
12776            hostname=d.get('hostname'),
12777            id=d.get('id'),
12778            name=d.get('name'),
12779            password=d.get('password'),
12780            port_override=d.get('port_override'),
12781            schema=d.get('schema'),
12782            secret_store_id=d.get('secret_store_id'),
12783            tags=d.get('tags'),
12784            username=d.get('username'),
12785        )
class Sybase:
12788class Sybase:
12789    '''
12790
12791    '''
12792    __slots__ = [
12793        'bind_interface',
12794        'egress_filter',
12795        'healthy',
12796        'hostname',
12797        'id',
12798        'name',
12799        'password',
12800        'port',
12801        'port_override',
12802        'secret_store_id',
12803        'tags',
12804        'username',
12805    ]
12806
12807    def __init__(
12808        self,
12809        bind_interface=None,
12810        egress_filter=None,
12811        healthy=None,
12812        hostname=None,
12813        id=None,
12814        name=None,
12815        password=None,
12816        port=None,
12817        port_override=None,
12818        secret_store_id=None,
12819        tags=None,
12820        username=None,
12821    ):
12822        self.bind_interface = bind_interface if bind_interface is not None else ''
12823        '''
12824         Bind interface
12825        '''
12826        self.egress_filter = egress_filter if egress_filter is not None else ''
12827        '''
12828         A filter applied to the routing logic to pin datasource to nodes.
12829        '''
12830        self.healthy = healthy if healthy is not None else False
12831        '''
12832         True if the datasource is reachable and the credentials are valid.
12833        '''
12834        self.hostname = hostname if hostname is not None else ''
12835        '''
12836
12837        '''
12838        self.id = id if id is not None else ''
12839        '''
12840         Unique identifier of the Resource.
12841        '''
12842        self.name = name if name is not None else ''
12843        '''
12844         Unique human-readable name of the Resource.
12845        '''
12846        self.password = password if password is not None else ''
12847        '''
12848
12849        '''
12850        self.port = port if port is not None else 0
12851        '''
12852
12853        '''
12854        self.port_override = port_override if port_override is not None else 0
12855        '''
12856
12857        '''
12858        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
12859        '''
12860         ID of the secret store containing credentials for this resource, if any.
12861        '''
12862        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12863        '''
12864         Tags is a map of key, value pairs.
12865        '''
12866        self.username = username if username is not None else ''
12867        '''
12868
12869        '''
12870
12871    def __repr__(self):
12872        return '<sdm.Sybase ' + \
12873            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
12874            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
12875            'healthy: ' + repr(self.healthy) + ' ' +\
12876            'hostname: ' + repr(self.hostname) + ' ' +\
12877            'id: ' + repr(self.id) + ' ' +\
12878            'name: ' + repr(self.name) + ' ' +\
12879            'password: ' + repr(self.password) + ' ' +\
12880            'port: ' + repr(self.port) + ' ' +\
12881            'port_override: ' + repr(self.port_override) + ' ' +\
12882            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
12883            'tags: ' + repr(self.tags) + ' ' +\
12884            'username: ' + repr(self.username) + ' ' +\
12885            '>'
12886
12887    def to_dict(self):
12888        return {
12889            'bind_interface': self.bind_interface,
12890            'egress_filter': self.egress_filter,
12891            'healthy': self.healthy,
12892            'hostname': self.hostname,
12893            'id': self.id,
12894            'name': self.name,
12895            'password': self.password,
12896            'port': self.port,
12897            'port_override': self.port_override,
12898            'secret_store_id': self.secret_store_id,
12899            'tags': self.tags,
12900            'username': self.username,
12901        }
12902
12903    @classmethod
12904    def from_dict(cls, d):
12905        return cls(
12906            bind_interface=d.get('bind_interface'),
12907            egress_filter=d.get('egress_filter'),
12908            healthy=d.get('healthy'),
12909            hostname=d.get('hostname'),
12910            id=d.get('id'),
12911            name=d.get('name'),
12912            password=d.get('password'),
12913            port=d.get('port'),
12914            port_override=d.get('port_override'),
12915            secret_store_id=d.get('secret_store_id'),
12916            tags=d.get('tags'),
12917            username=d.get('username'),
12918        )
Sybase( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
12807    def __init__(
12808        self,
12809        bind_interface=None,
12810        egress_filter=None,
12811        healthy=None,
12812        hostname=None,
12813        id=None,
12814        name=None,
12815        password=None,
12816        port=None,
12817        port_override=None,
12818        secret_store_id=None,
12819        tags=None,
12820        username=None,
12821    ):
12822        self.bind_interface = bind_interface if bind_interface is not None else ''
12823        '''
12824         Bind interface
12825        '''
12826        self.egress_filter = egress_filter if egress_filter is not None else ''
12827        '''
12828         A filter applied to the routing logic to pin datasource to nodes.
12829        '''
12830        self.healthy = healthy if healthy is not None else False
12831        '''
12832         True if the datasource is reachable and the credentials are valid.
12833        '''
12834        self.hostname = hostname if hostname is not None else ''
12835        '''
12836
12837        '''
12838        self.id = id if id is not None else ''
12839        '''
12840         Unique identifier of the Resource.
12841        '''
12842        self.name = name if name is not None else ''
12843        '''
12844         Unique human-readable name of the Resource.
12845        '''
12846        self.password = password if password is not None else ''
12847        '''
12848
12849        '''
12850        self.port = port if port is not None else 0
12851        '''
12852
12853        '''
12854        self.port_override = port_override if port_override is not None else 0
12855        '''
12856
12857        '''
12858        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
12859        '''
12860         ID of the secret store containing credentials for this resource, if any.
12861        '''
12862        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12863        '''
12864         Tags is a map of key, value pairs.
12865        '''
12866        self.username = username if username is not None else ''
12867        '''
12868
12869        '''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
12887    def to_dict(self):
12888        return {
12889            'bind_interface': self.bind_interface,
12890            'egress_filter': self.egress_filter,
12891            'healthy': self.healthy,
12892            'hostname': self.hostname,
12893            'id': self.id,
12894            'name': self.name,
12895            'password': self.password,
12896            'port': self.port,
12897            'port_override': self.port_override,
12898            'secret_store_id': self.secret_store_id,
12899            'tags': self.tags,
12900            'username': self.username,
12901        }
@classmethod
def from_dict(cls, d)
12903    @classmethod
12904    def from_dict(cls, d):
12905        return cls(
12906            bind_interface=d.get('bind_interface'),
12907            egress_filter=d.get('egress_filter'),
12908            healthy=d.get('healthy'),
12909            hostname=d.get('hostname'),
12910            id=d.get('id'),
12911            name=d.get('name'),
12912            password=d.get('password'),
12913            port=d.get('port'),
12914            port_override=d.get('port_override'),
12915            secret_store_id=d.get('secret_store_id'),
12916            tags=d.get('tags'),
12917            username=d.get('username'),
12918        )
class SybaseIQ:
12921class SybaseIQ:
12922    '''
12923
12924    '''
12925    __slots__ = [
12926        'bind_interface',
12927        'egress_filter',
12928        'healthy',
12929        'hostname',
12930        'id',
12931        'name',
12932        'password',
12933        'port',
12934        'port_override',
12935        'secret_store_id',
12936        'tags',
12937        'username',
12938    ]
12939
12940    def __init__(
12941        self,
12942        bind_interface=None,
12943        egress_filter=None,
12944        healthy=None,
12945        hostname=None,
12946        id=None,
12947        name=None,
12948        password=None,
12949        port=None,
12950        port_override=None,
12951        secret_store_id=None,
12952        tags=None,
12953        username=None,
12954    ):
12955        self.bind_interface = bind_interface if bind_interface is not None else ''
12956        '''
12957         Bind interface
12958        '''
12959        self.egress_filter = egress_filter if egress_filter is not None else ''
12960        '''
12961         A filter applied to the routing logic to pin datasource to nodes.
12962        '''
12963        self.healthy = healthy if healthy is not None else False
12964        '''
12965         True if the datasource is reachable and the credentials are valid.
12966        '''
12967        self.hostname = hostname if hostname is not None else ''
12968        '''
12969
12970        '''
12971        self.id = id if id is not None else ''
12972        '''
12973         Unique identifier of the Resource.
12974        '''
12975        self.name = name if name is not None else ''
12976        '''
12977         Unique human-readable name of the Resource.
12978        '''
12979        self.password = password if password is not None else ''
12980        '''
12981
12982        '''
12983        self.port = port if port is not None else 0
12984        '''
12985
12986        '''
12987        self.port_override = port_override if port_override is not None else 0
12988        '''
12989
12990        '''
12991        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
12992        '''
12993         ID of the secret store containing credentials for this resource, if any.
12994        '''
12995        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12996        '''
12997         Tags is a map of key, value pairs.
12998        '''
12999        self.username = username if username is not None else ''
13000        '''
13001
13002        '''
13003
13004    def __repr__(self):
13005        return '<sdm.SybaseIQ ' + \
13006            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
13007            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
13008            'healthy: ' + repr(self.healthy) + ' ' +\
13009            'hostname: ' + repr(self.hostname) + ' ' +\
13010            'id: ' + repr(self.id) + ' ' +\
13011            'name: ' + repr(self.name) + ' ' +\
13012            'password: ' + repr(self.password) + ' ' +\
13013            'port: ' + repr(self.port) + ' ' +\
13014            'port_override: ' + repr(self.port_override) + ' ' +\
13015            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
13016            'tags: ' + repr(self.tags) + ' ' +\
13017            'username: ' + repr(self.username) + ' ' +\
13018            '>'
13019
13020    def to_dict(self):
13021        return {
13022            'bind_interface': self.bind_interface,
13023            'egress_filter': self.egress_filter,
13024            'healthy': self.healthy,
13025            'hostname': self.hostname,
13026            'id': self.id,
13027            'name': self.name,
13028            'password': self.password,
13029            'port': self.port,
13030            'port_override': self.port_override,
13031            'secret_store_id': self.secret_store_id,
13032            'tags': self.tags,
13033            'username': self.username,
13034        }
13035
13036    @classmethod
13037    def from_dict(cls, d):
13038        return cls(
13039            bind_interface=d.get('bind_interface'),
13040            egress_filter=d.get('egress_filter'),
13041            healthy=d.get('healthy'),
13042            hostname=d.get('hostname'),
13043            id=d.get('id'),
13044            name=d.get('name'),
13045            password=d.get('password'),
13046            port=d.get('port'),
13047            port_override=d.get('port_override'),
13048            secret_store_id=d.get('secret_store_id'),
13049            tags=d.get('tags'),
13050            username=d.get('username'),
13051        )
SybaseIQ( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
12940    def __init__(
12941        self,
12942        bind_interface=None,
12943        egress_filter=None,
12944        healthy=None,
12945        hostname=None,
12946        id=None,
12947        name=None,
12948        password=None,
12949        port=None,
12950        port_override=None,
12951        secret_store_id=None,
12952        tags=None,
12953        username=None,
12954    ):
12955        self.bind_interface = bind_interface if bind_interface is not None else ''
12956        '''
12957         Bind interface
12958        '''
12959        self.egress_filter = egress_filter if egress_filter is not None else ''
12960        '''
12961         A filter applied to the routing logic to pin datasource to nodes.
12962        '''
12963        self.healthy = healthy if healthy is not None else False
12964        '''
12965         True if the datasource is reachable and the credentials are valid.
12966        '''
12967        self.hostname = hostname if hostname is not None else ''
12968        '''
12969
12970        '''
12971        self.id = id if id is not None else ''
12972        '''
12973         Unique identifier of the Resource.
12974        '''
12975        self.name = name if name is not None else ''
12976        '''
12977         Unique human-readable name of the Resource.
12978        '''
12979        self.password = password if password is not None else ''
12980        '''
12981
12982        '''
12983        self.port = port if port is not None else 0
12984        '''
12985
12986        '''
12987        self.port_override = port_override if port_override is not None else 0
12988        '''
12989
12990        '''
12991        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
12992        '''
12993         ID of the secret store containing credentials for this resource, if any.
12994        '''
12995        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
12996        '''
12997         Tags is a map of key, value pairs.
12998        '''
12999        self.username = username if username is not None else ''
13000        '''
13001
13002        '''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
13020    def to_dict(self):
13021        return {
13022            'bind_interface': self.bind_interface,
13023            'egress_filter': self.egress_filter,
13024            'healthy': self.healthy,
13025            'hostname': self.hostname,
13026            'id': self.id,
13027            'name': self.name,
13028            'password': self.password,
13029            'port': self.port,
13030            'port_override': self.port_override,
13031            'secret_store_id': self.secret_store_id,
13032            'tags': self.tags,
13033            'username': self.username,
13034        }
@classmethod
def from_dict(cls, d)
13036    @classmethod
13037    def from_dict(cls, d):
13038        return cls(
13039            bind_interface=d.get('bind_interface'),
13040            egress_filter=d.get('egress_filter'),
13041            healthy=d.get('healthy'),
13042            hostname=d.get('hostname'),
13043            id=d.get('id'),
13044            name=d.get('name'),
13045            password=d.get('password'),
13046            port=d.get('port'),
13047            port_override=d.get('port_override'),
13048            secret_store_id=d.get('secret_store_id'),
13049            tags=d.get('tags'),
13050            username=d.get('username'),
13051        )
class Tag:
13054class Tag:
13055    '''
13056
13057    '''
13058    __slots__ = [
13059        'name',
13060        'value',
13061    ]
13062
13063    def __init__(
13064        self,
13065        name=None,
13066        value=None,
13067    ):
13068        self.name = name if name is not None else ''
13069        '''
13070
13071        '''
13072        self.value = value if value is not None else ''
13073        '''
13074
13075        '''
13076
13077    def __repr__(self):
13078        return '<sdm.Tag ' + \
13079            'name: ' + repr(self.name) + ' ' +\
13080            'value: ' + repr(self.value) + ' ' +\
13081            '>'
13082
13083    def to_dict(self):
13084        return {
13085            'name': self.name,
13086            'value': self.value,
13087        }
13088
13089    @classmethod
13090    def from_dict(cls, d):
13091        return cls(
13092            name=d.get('name'),
13093            value=d.get('value'),
13094        )
Tag(name=None, value=None)
13063    def __init__(
13064        self,
13065        name=None,
13066        value=None,
13067    ):
13068        self.name = name if name is not None else ''
13069        '''
13070
13071        '''
13072        self.value = value if value is not None else ''
13073        '''
13074
13075        '''
name
value
def to_dict(self)
13083    def to_dict(self):
13084        return {
13085            'name': self.name,
13086            'value': self.value,
13087        }
@classmethod
def from_dict(cls, d)
13089    @classmethod
13090    def from_dict(cls, d):
13091        return cls(
13092            name=d.get('name'),
13093            value=d.get('value'),
13094        )
class Teradata:
13097class Teradata:
13098    '''
13099
13100    '''
13101    __slots__ = [
13102        'bind_interface',
13103        'egress_filter',
13104        'healthy',
13105        'hostname',
13106        'id',
13107        'name',
13108        'password',
13109        'port',
13110        'port_override',
13111        'secret_store_id',
13112        'tags',
13113        'username',
13114    ]
13115
13116    def __init__(
13117        self,
13118        bind_interface=None,
13119        egress_filter=None,
13120        healthy=None,
13121        hostname=None,
13122        id=None,
13123        name=None,
13124        password=None,
13125        port=None,
13126        port_override=None,
13127        secret_store_id=None,
13128        tags=None,
13129        username=None,
13130    ):
13131        self.bind_interface = bind_interface if bind_interface is not None else ''
13132        '''
13133         Bind interface
13134        '''
13135        self.egress_filter = egress_filter if egress_filter is not None else ''
13136        '''
13137         A filter applied to the routing logic to pin datasource to nodes.
13138        '''
13139        self.healthy = healthy if healthy is not None else False
13140        '''
13141         True if the datasource is reachable and the credentials are valid.
13142        '''
13143        self.hostname = hostname if hostname is not None else ''
13144        '''
13145
13146        '''
13147        self.id = id if id is not None else ''
13148        '''
13149         Unique identifier of the Resource.
13150        '''
13151        self.name = name if name is not None else ''
13152        '''
13153         Unique human-readable name of the Resource.
13154        '''
13155        self.password = password if password is not None else ''
13156        '''
13157
13158        '''
13159        self.port = port if port is not None else 0
13160        '''
13161
13162        '''
13163        self.port_override = port_override if port_override is not None else 0
13164        '''
13165
13166        '''
13167        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
13168        '''
13169         ID of the secret store containing credentials for this resource, if any.
13170        '''
13171        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
13172        '''
13173         Tags is a map of key, value pairs.
13174        '''
13175        self.username = username if username is not None else ''
13176        '''
13177
13178        '''
13179
13180    def __repr__(self):
13181        return '<sdm.Teradata ' + \
13182            'bind_interface: ' + repr(self.bind_interface) + ' ' +\
13183            'egress_filter: ' + repr(self.egress_filter) + ' ' +\
13184            'healthy: ' + repr(self.healthy) + ' ' +\
13185            'hostname: ' + repr(self.hostname) + ' ' +\
13186            'id: ' + repr(self.id) + ' ' +\
13187            'name: ' + repr(self.name) + ' ' +\
13188            'password: ' + repr(self.password) + ' ' +\
13189            'port: ' + repr(self.port) + ' ' +\
13190            'port_override: ' + repr(self.port_override) + ' ' +\
13191            'secret_store_id: ' + repr(self.secret_store_id) + ' ' +\
13192            'tags: ' + repr(self.tags) + ' ' +\
13193            'username: ' + repr(self.username) + ' ' +\
13194            '>'
13195
13196    def to_dict(self):
13197        return {
13198            'bind_interface': self.bind_interface,
13199            'egress_filter': self.egress_filter,
13200            'healthy': self.healthy,
13201            'hostname': self.hostname,
13202            'id': self.id,
13203            'name': self.name,
13204            'password': self.password,
13205            'port': self.port,
13206            'port_override': self.port_override,
13207            'secret_store_id': self.secret_store_id,
13208            'tags': self.tags,
13209            'username': self.username,
13210        }
13211
13212    @classmethod
13213    def from_dict(cls, d):
13214        return cls(
13215            bind_interface=d.get('bind_interface'),
13216            egress_filter=d.get('egress_filter'),
13217            healthy=d.get('healthy'),
13218            hostname=d.get('hostname'),
13219            id=d.get('id'),
13220            name=d.get('name'),
13221            password=d.get('password'),
13222            port=d.get('port'),
13223            port_override=d.get('port_override'),
13224            secret_store_id=d.get('secret_store_id'),
13225            tags=d.get('tags'),
13226            username=d.get('username'),
13227        )
Teradata( bind_interface=None, egress_filter=None, healthy=None, hostname=None, id=None, name=None, password=None, port=None, port_override=None, secret_store_id=None, tags=None, username=None)
13116    def __init__(
13117        self,
13118        bind_interface=None,
13119        egress_filter=None,
13120        healthy=None,
13121        hostname=None,
13122        id=None,
13123        name=None,
13124        password=None,
13125        port=None,
13126        port_override=None,
13127        secret_store_id=None,
13128        tags=None,
13129        username=None,
13130    ):
13131        self.bind_interface = bind_interface if bind_interface is not None else ''
13132        '''
13133         Bind interface
13134        '''
13135        self.egress_filter = egress_filter if egress_filter is not None else ''
13136        '''
13137         A filter applied to the routing logic to pin datasource to nodes.
13138        '''
13139        self.healthy = healthy if healthy is not None else False
13140        '''
13141         True if the datasource is reachable and the credentials are valid.
13142        '''
13143        self.hostname = hostname if hostname is not None else ''
13144        '''
13145
13146        '''
13147        self.id = id if id is not None else ''
13148        '''
13149         Unique identifier of the Resource.
13150        '''
13151        self.name = name if name is not None else ''
13152        '''
13153         Unique human-readable name of the Resource.
13154        '''
13155        self.password = password if password is not None else ''
13156        '''
13157
13158        '''
13159        self.port = port if port is not None else 0
13160        '''
13161
13162        '''
13163        self.port_override = port_override if port_override is not None else 0
13164        '''
13165
13166        '''
13167        self.secret_store_id = secret_store_id if secret_store_id is not None else ''
13168        '''
13169         ID of the secret store containing credentials for this resource, if any.
13170        '''
13171        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
13172        '''
13173         Tags is a map of key, value pairs.
13174        '''
13175        self.username = username if username is not None else ''
13176        '''
13177
13178        '''
bind_interface

Bind interface

egress_filter

A filter applied to the routing logic to pin datasource to nodes.

healthy

True if the datasource is reachable and the credentials are valid.

hostname
id

Unique identifier of the Resource.

name

Unique human-readable name of the Resource.

password
port
port_override
secret_store_id

ID of the secret store containing credentials for this resource, if any.

tags

Tags is a map of key, value pairs.

username
def to_dict(self)
13196    def to_dict(self):
13197        return {
13198            'bind_interface': self.bind_interface,
13199            'egress_filter': self.egress_filter,
13200            'healthy': self.healthy,
13201            'hostname': self.hostname,
13202            'id': self.id,
13203            'name': self.name,
13204            'password': self.password,
13205            'port': self.port,
13206            'port_override': self.port_override,
13207            'secret_store_id': self.secret_store_id,
13208            'tags': self.tags,
13209            'username': self.username,
13210        }
@classmethod
def from_dict(cls, d)
13212    @classmethod
13213    def from_dict(cls, d):
13214        return cls(
13215            bind_interface=d.get('bind_interface'),
13216            egress_filter=d.get('egress_filter'),
13217            healthy=d.get('healthy'),
13218            hostname=d.get('hostname'),
13219            id=d.get('id'),
13220            name=d.get('name'),
13221            password=d.get('password'),
13222            port=d.get('port'),
13223            port_override=d.get('port_override'),
13224            secret_store_id=d.get('secret_store_id'),
13225            tags=d.get('tags'),
13226            username=d.get('username'),
13227        )
class UpdateResponseMetadata:
13230class UpdateResponseMetadata:
13231    '''
13232     UpdateResponseMetadata is reserved for future use.
13233    '''
13234    __slots__ = []
13235
13236    def __init__(self, ):
13237        pass
13238
13239    def __repr__(self):
13240        return '<sdm.UpdateResponseMetadata ' + \
13241            '>'
13242
13243    def to_dict(self):
13244        return {}
13245
13246    @classmethod
13247    def from_dict(cls, d):
13248        return cls()

UpdateResponseMetadata is reserved for future use.

UpdateResponseMetadata()
13236    def __init__(self, ):
13237        pass
def to_dict(self)
13243    def to_dict(self):
13244        return {}
@classmethod
def from_dict(cls, d)
13246    @classmethod
13247    def from_dict(cls, d):
13248        return cls()
class User:
13251class User:
13252    '''
13253     A User can connect to resources they are granted directly, or granted
13254     via roles.
13255    '''
13256    __slots__ = [
13257        'email',
13258        'first_name',
13259        'id',
13260        'last_name',
13261        'suspended',
13262        'tags',
13263    ]
13264
13265    def __init__(
13266        self,
13267        email=None,
13268        first_name=None,
13269        id=None,
13270        last_name=None,
13271        suspended=None,
13272        tags=None,
13273    ):
13274        self.email = email if email is not None else ''
13275        '''
13276         The User's email address. Must be unique.
13277        '''
13278        self.first_name = first_name if first_name is not None else ''
13279        '''
13280         The User's first name.
13281        '''
13282        self.id = id if id is not None else ''
13283        '''
13284         Unique identifier of the User.
13285        '''
13286        self.last_name = last_name if last_name is not None else ''
13287        '''
13288         The User's last name.
13289        '''
13290        self.suspended = suspended if suspended is not None else False
13291        '''
13292         The User's suspended state.
13293        '''
13294        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
13295        '''
13296         Tags is a map of key, value pairs.
13297        '''
13298
13299    def __repr__(self):
13300        return '<sdm.User ' + \
13301            'email: ' + repr(self.email) + ' ' +\
13302            'first_name: ' + repr(self.first_name) + ' ' +\
13303            'id: ' + repr(self.id) + ' ' +\
13304            'last_name: ' + repr(self.last_name) + ' ' +\
13305            'suspended: ' + repr(self.suspended) + ' ' +\
13306            'tags: ' + repr(self.tags) + ' ' +\
13307            '>'
13308
13309    def to_dict(self):
13310        return {
13311            'email': self.email,
13312            'first_name': self.first_name,
13313            'id': self.id,
13314            'last_name': self.last_name,
13315            'suspended': self.suspended,
13316            'tags': self.tags,
13317        }
13318
13319    @classmethod
13320    def from_dict(cls, d):
13321        return cls(
13322            email=d.get('email'),
13323            first_name=d.get('first_name'),
13324            id=d.get('id'),
13325            last_name=d.get('last_name'),
13326            suspended=d.get('suspended'),
13327            tags=d.get('tags'),
13328        )

A User can connect to resources they are granted directly, or granted via roles.

User( email=None, first_name=None, id=None, last_name=None, suspended=None, tags=None)
13265    def __init__(
13266        self,
13267        email=None,
13268        first_name=None,
13269        id=None,
13270        last_name=None,
13271        suspended=None,
13272        tags=None,
13273    ):
13274        self.email = email if email is not None else ''
13275        '''
13276         The User's email address. Must be unique.
13277        '''
13278        self.first_name = first_name if first_name is not None else ''
13279        '''
13280         The User's first name.
13281        '''
13282        self.id = id if id is not None else ''
13283        '''
13284         Unique identifier of the User.
13285        '''
13286        self.last_name = last_name if last_name is not None else ''
13287        '''
13288         The User's last name.
13289        '''
13290        self.suspended = suspended if suspended is not None else False
13291        '''
13292         The User's suspended state.
13293        '''
13294        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
13295        '''
13296         Tags is a map of key, value pairs.
13297        '''
email

The User's email address. Must be unique.

first_name

The User's first name.

id

Unique identifier of the User.

last_name

The User's last name.

suspended

The User's suspended state.

tags

Tags is a map of key, value pairs.

def to_dict(self)
13309    def to_dict(self):
13310        return {
13311            'email': self.email,
13312            'first_name': self.first_name,
13313            'id': self.id,
13314            'last_name': self.last_name,
13315            'suspended': self.suspended,
13316            'tags': self.tags,
13317        }
@classmethod
def from_dict(cls, d)
13319    @classmethod
13320    def from_dict(cls, d):
13321        return cls(
13322            email=d.get('email'),
13323            first_name=d.get('first_name'),
13324            id=d.get('id'),
13325            last_name=d.get('last_name'),
13326            suspended=d.get('suspended'),
13327            tags=d.get('tags'),
13328        )
class VaultAppRoleStore:
13331class VaultAppRoleStore:
13332    '''
13333
13334    '''
13335    __slots__ = [
13336        'id',
13337        'name',
13338        'namespace',
13339        'server_address',
13340        'tags',
13341    ]
13342
13343    def __init__(
13344        self,
13345        id=None,
13346        name=None,
13347        namespace=None,
13348        server_address=None,
13349        tags=None,
13350    ):
13351        self.id = id if id is not None else ''
13352        '''
13353         Unique identifier of the SecretStore.
13354        '''
13355        self.name = name if name is not None else ''
13356        '''
13357         Unique human-readable name of the SecretStore.
13358        '''
13359        self.namespace = namespace if namespace is not None else ''
13360        '''
13361
13362        '''
13363        self.server_address = server_address if server_address is not None else ''
13364        '''
13365
13366        '''
13367        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
13368        '''
13369         Tags is a map of key, value pairs.
13370        '''
13371
13372    def __repr__(self):
13373        return '<sdm.VaultAppRoleStore ' + \
13374            'id: ' + repr(self.id) + ' ' +\
13375            'name: ' + repr(self.name) + ' ' +\
13376            'namespace: ' + repr(self.namespace) + ' ' +\
13377            'server_address: ' + repr(self.server_address) + ' ' +\
13378            'tags: ' + repr(self.tags) + ' ' +\
13379            '>'
13380
13381    def to_dict(self):
13382        return {
13383            'id': self.id,
13384            'name': self.name,
13385            'namespace': self.namespace,
13386            'server_address': self.server_address,
13387            'tags': self.tags,
13388        }
13389
13390    @classmethod
13391    def from_dict(cls, d):
13392        return cls(
13393            id=d.get('id'),
13394            name=d.get('name'),
13395            namespace=d.get('namespace'),
13396            server_address=d.get('server_address'),
13397            tags=d.get('tags'),
13398        )
VaultAppRoleStore(id=None, name=None, namespace=None, server_address=None, tags=None)
13343    def __init__(
13344        self,
13345        id=None,
13346        name=None,
13347        namespace=None,
13348        server_address=None,
13349        tags=None,
13350    ):
13351        self.id = id if id is not None else ''
13352        '''
13353         Unique identifier of the SecretStore.
13354        '''
13355        self.name = name if name is not None else ''
13356        '''
13357         Unique human-readable name of the SecretStore.
13358        '''
13359        self.namespace = namespace if namespace is not None else ''
13360        '''
13361
13362        '''
13363        self.server_address = server_address if server_address is not None else ''
13364        '''
13365
13366        '''
13367        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
13368        '''
13369         Tags is a map of key, value pairs.
13370        '''
id

Unique identifier of the SecretStore.

name

Unique human-readable name of the SecretStore.

namespace
server_address
tags

Tags is a map of key, value pairs.

def to_dict(self)
13381    def to_dict(self):
13382        return {
13383            'id': self.id,
13384            'name': self.name,
13385            'namespace': self.namespace,
13386            'server_address': self.server_address,
13387            'tags': self.tags,
13388        }
@classmethod
def from_dict(cls, d)
13390    @classmethod
13391    def from_dict(cls, d):
13392        return cls(
13393            id=d.get('id'),
13394            name=d.get('name'),
13395            namespace=d.get('namespace'),
13396            server_address=d.get('server_address'),
13397            tags=d.get('tags'),
13398        )
class VaultTLSStore:
13401class VaultTLSStore:
13402    '''
13403
13404    '''
13405    __slots__ = [
13406        'ca_cert_path',
13407        'client_cert_path',
13408        'client_key_path',
13409        'id',
13410        'name',
13411        'namespace',
13412        'server_address',
13413        'tags',
13414    ]
13415
13416    def __init__(
13417        self,
13418        ca_cert_path=None,
13419        client_cert_path=None,
13420        client_key_path=None,
13421        id=None,
13422        name=None,
13423        namespace=None,
13424        server_address=None,
13425        tags=None,
13426    ):
13427        self.ca_cert_path = ca_cert_path if ca_cert_path is not None else ''
13428        '''
13429
13430        '''
13431        self.client_cert_path = client_cert_path if client_cert_path is not None else ''
13432        '''
13433
13434        '''
13435        self.client_key_path = client_key_path if client_key_path is not None else ''
13436        '''
13437
13438        '''
13439        self.id = id if id is not None else ''
13440        '''
13441         Unique identifier of the SecretStore.
13442        '''
13443        self.name = name if name is not None else ''
13444        '''
13445         Unique human-readable name of the SecretStore.
13446        '''
13447        self.namespace = namespace if namespace is not None else ''
13448        '''
13449
13450        '''
13451        self.server_address = server_address if server_address is not None else ''
13452        '''
13453
13454        '''
13455        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
13456        '''
13457         Tags is a map of key, value pairs.
13458        '''
13459
13460    def __repr__(self):
13461        return '<sdm.VaultTLSStore ' + \
13462            'ca_cert_path: ' + repr(self.ca_cert_path) + ' ' +\
13463            'client_cert_path: ' + repr(self.client_cert_path) + ' ' +\
13464            'client_key_path: ' + repr(self.client_key_path) + ' ' +\
13465            'id: ' + repr(self.id) + ' ' +\
13466            'name: ' + repr(self.name) + ' ' +\
13467            'namespace: ' + repr(self.namespace) + ' ' +\
13468            'server_address: ' + repr(self.server_address) + ' ' +\
13469            'tags: ' + repr(self.tags) + ' ' +\
13470            '>'
13471
13472    def to_dict(self):
13473        return {
13474            'ca_cert_path': self.ca_cert_path,
13475            'client_cert_path': self.client_cert_path,
13476            'client_key_path': self.client_key_path,
13477            'id': self.id,
13478            'name': self.name,
13479            'namespace': self.namespace,
13480            'server_address': self.server_address,
13481            'tags': self.tags,
13482        }
13483
13484    @classmethod
13485    def from_dict(cls, d):
13486        return cls(
13487            ca_cert_path=d.get('ca_cert_path'),
13488            client_cert_path=d.get('client_cert_path'),
13489            client_key_path=d.get('client_key_path'),
13490            id=d.get('id'),
13491            name=d.get('name'),
13492            namespace=d.get('namespace'),
13493            server_address=d.get('server_address'),
13494            tags=d.get('tags'),
13495        )
VaultTLSStore( ca_cert_path=None, client_cert_path=None, client_key_path=None, id=None, name=None, namespace=None, server_address=None, tags=None)
13416    def __init__(
13417        self,
13418        ca_cert_path=None,
13419        client_cert_path=None,
13420        client_key_path=None,
13421        id=None,
13422        name=None,
13423        namespace=None,
13424        server_address=None,
13425        tags=None,
13426    ):
13427        self.ca_cert_path = ca_cert_path if ca_cert_path is not None else ''
13428        '''
13429
13430        '''
13431        self.client_cert_path = client_cert_path if client_cert_path is not None else ''
13432        '''
13433
13434        '''
13435        self.client_key_path = client_key_path if client_key_path is not None else ''
13436        '''
13437
13438        '''
13439        self.id = id if id is not None else ''
13440        '''
13441         Unique identifier of the SecretStore.
13442        '''
13443        self.name = name if name is not None else ''
13444        '''
13445         Unique human-readable name of the SecretStore.
13446        '''
13447        self.namespace = namespace if namespace is not None else ''
13448        '''
13449
13450        '''
13451        self.server_address = server_address if server_address is not None else ''
13452        '''
13453
13454        '''
13455        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
13456        '''
13457         Tags is a map of key, value pairs.
13458        '''
ca_cert_path
client_cert_path
client_key_path
id

Unique identifier of the SecretStore.

name

Unique human-readable name of the SecretStore.

namespace
server_address
tags

Tags is a map of key, value pairs.

def to_dict(self)
13472    def to_dict(self):
13473        return {
13474            'ca_cert_path': self.ca_cert_path,
13475            'client_cert_path': self.client_cert_path,
13476            'client_key_path': self.client_key_path,
13477            'id': self.id,
13478            'name': self.name,
13479            'namespace': self.namespace,
13480            'server_address': self.server_address,
13481            'tags': self.tags,
13482        }
@classmethod
def from_dict(cls, d)
13484    @classmethod
13485    def from_dict(cls, d):
13486        return cls(
13487            ca_cert_path=d.get('ca_cert_path'),
13488            client_cert_path=d.get('client_cert_path'),
13489            client_key_path=d.get('client_key_path'),
13490            id=d.get('id'),
13491            name=d.get('name'),
13492            namespace=d.get('namespace'),
13493            server_address=d.get('server_address'),
13494            tags=d.get('tags'),
13495        )
class VaultTokenStore:
13498class VaultTokenStore:
13499    '''
13500
13501    '''
13502    __slots__ = [
13503        'id',
13504        'name',
13505        'namespace',
13506        'server_address',
13507        'tags',
13508    ]
13509
13510    def __init__(
13511        self,
13512        id=None,
13513        name=None,
13514        namespace=None,
13515        server_address=None,
13516        tags=None,
13517    ):
13518        self.id = id if id is not None else ''
13519        '''
13520         Unique identifier of the SecretStore.
13521        '''
13522        self.name = name if name is not None else ''
13523        '''
13524         Unique human-readable name of the SecretStore.
13525        '''
13526        self.namespace = namespace if namespace is not None else ''
13527        '''
13528
13529        '''
13530        self.server_address = server_address if server_address is not None else ''
13531        '''
13532
13533        '''
13534        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
13535        '''
13536         Tags is a map of key, value pairs.
13537        '''
13538
13539    def __repr__(self):
13540        return '<sdm.VaultTokenStore ' + \
13541            'id: ' + repr(self.id) + ' ' +\
13542            'name: ' + repr(self.name) + ' ' +\
13543            'namespace: ' + repr(self.namespace) + ' ' +\
13544            'server_address: ' + repr(self.server_address) + ' ' +\
13545            'tags: ' + repr(self.tags) + ' ' +\
13546            '>'
13547
13548    def to_dict(self):
13549        return {
13550            'id': self.id,
13551            'name': self.name,
13552            'namespace': self.namespace,
13553            'server_address': self.server_address,
13554            'tags': self.tags,
13555        }
13556
13557    @classmethod
13558    def from_dict(cls, d):
13559        return cls(
13560            id=d.get('id'),
13561            name=d.get('name'),
13562            namespace=d.get('namespace'),
13563            server_address=d.get('server_address'),
13564            tags=d.get('tags'),
13565        )
VaultTokenStore(id=None, name=None, namespace=None, server_address=None, tags=None)
13510    def __init__(
13511        self,
13512        id=None,
13513        name=None,
13514        namespace=None,
13515        server_address=None,
13516        tags=None,
13517    ):
13518        self.id = id if id is not None else ''
13519        '''
13520         Unique identifier of the SecretStore.
13521        '''
13522        self.name = name if name is not None else ''
13523        '''
13524         Unique human-readable name of the SecretStore.
13525        '''
13526        self.namespace = namespace if namespace is not None else ''
13527        '''
13528
13529        '''
13530        self.server_address = server_address if server_address is not None else ''
13531        '''
13532
13533        '''
13534        self.tags = tags if tags is not None else _porcelain_zero_value_tags()
13535        '''
13536         Tags is a map of key, value pairs.
13537        '''
id

Unique identifier of the SecretStore.

name

Unique human-readable name of the SecretStore.

namespace
server_address
tags

Tags is a map of key, value pairs.

def to_dict(self)
13548    def to_dict(self):
13549        return {
13550            'id': self.id,
13551            'name': self.name,
13552            'namespace': self.namespace,
13553            'server_address': self.server_address,
13554            'tags': self.tags,
13555        }
@classmethod
def from_dict(cls, d)
13557    @classmethod
13558    def from_dict(cls, d):
13559        return cls(
13560            id=d.get('id'),
13561            name=d.get('name'),
13562            namespace=d.get('namespace'),
13563            server_address=d.get('server_address'),
13564            tags=d.get('tags'),
13565        )